    {-# LANGUAGE ConstraintKinds #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeApplications #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
                                          -- in module Language.Haskell.Syntax.Extension

    {-# OPTIONS_GHC -Wno-orphans #-} -- Outputable
    {-# LANGUAGE InstanceSigs #-}

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

    -- | Abstract syntax of global declarations.
    --
    -- Definitions for: @SynDecl@ and @ConDecl@, @ClassDecl@,
    -- @InstDecl@, @DefaultDecl@ and @ForeignDecl@.
    module GHC.Hs.Decls (
      -- * Toplevel declarations
      HsDecl(..), LHsDecl, HsDataDefn(..), HsDeriving, LHsFunDep,
      HsDerivingClause(..), LHsDerivingClause, DerivClauseTys(..), LDerivClauseTys,
      NewOrData, newOrDataToFlavour, anyLConIsGadt,
      StandaloneKindSig(..), LStandaloneKindSig, standaloneKindSigName,

      -- ** Class or type declarations
      TyClDecl(..), LTyClDecl, DataDeclRn(..),
      AnnDataDefn(..),
      AnnClassDecl(..),
      AnnSynDecl(..),
      AnnFamilyDecl(..),
      AnnClsInstDecl(..),
      TyClGroup(..),
      tyClGroupTyClDecls, tyClGroupInstDecls, tyClGroupRoleDecls,
      tyClGroupKindSigs,
      isClassDecl, isDataDecl, isSynDecl, tcdName,
      isFamilyDecl, isTypeFamilyDecl, isDataFamilyDecl,
      isOpenTypeFamilyInfo, isClosedTypeFamilyInfo,
      tyFamInstDeclName, tyFamInstDeclLName,
      countTyClDecls, pprTyClDeclFlavour,
      tyClDeclLName, tyClDeclTyVars,
      hsDeclHasCusk, famResultKindSignature,
      FamilyDecl(..), LFamilyDecl,
      FunDep(..), ppDataDefnHeader,
      pp_vanilla_decl_head,

      -- ** Instance declarations
      InstDecl(..), LInstDecl, FamilyInfo(..),
      TyFamInstDecl(..), LTyFamInstDecl, instDeclDataFamInsts,
      TyFamDefltDecl, LTyFamDefltDecl,
      DataFamInstDecl(..), LDataFamInstDecl,
      pprDataFamInstFlavour, pprTyFamInstDecl, pprHsFamInstLHS,
      FamEqn(..), TyFamInstEqn, LTyFamInstEqn, HsFamEqnPats,
      LClsInstDecl, ClsInstDecl(..),

      -- ** Standalone deriving declarations
      DerivDecl(..), LDerivDecl, AnnDerivDecl,
      -- ** Deriving strategies
      DerivStrategy(..), LDerivStrategy,
      derivStrategyName, foldDerivStrategy, mapDerivStrategy,
      XViaStrategyPs(..),
      -- ** @RULE@ declarations
      LRuleDecls,RuleDecls(..),RuleDecl(..),LRuleDecl,HsRuleRn(..),
      HsRuleAnn(..), ActivationAnn(..),
      RuleBndr(..),LRuleBndr,
      collectRuleBndrSigTys,
      flattenRuleDecls, pprFullRuleName,
      -- ** @default@ declarations
      DefaultDecl(..), LDefaultDecl,
      -- ** Template haskell declaration splice
      SpliceDecoration(..),
      SpliceDecl(..), LSpliceDecl,
      -- ** Foreign function interface declarations
      ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..),
      CImportSpec(..),
      -- ** Data-constructor declarations
      ConDecl(..), LConDecl,
      HsConDeclH98Details, HsConDeclGADTDetails(..),
      AnnConDeclH98(..), AnnConDeclGADT(..),
      hsConDeclTheta,
      getConNames, getRecConArgs_maybe,
      -- ** Document comments
      DocDecl(..), LDocDecl, docDeclDoc,
      -- ** Deprecations
      WarnDecl(..), LWarnDecl,
      WarnDecls(..), LWarnDecls,
      -- ** Annotations
      AnnDecl(..), LAnnDecl,
      AnnProvenance(..), annProvenanceName_maybe,
      -- ** Role annotations
      RoleAnnotDecl(..), LRoleAnnotDecl, roleAnnotDeclName,
      -- ** Injective type families
      FamilyResultSig(..), LFamilyResultSig, InjectivityAnn(..), LInjectivityAnn,
      resultVariableName, familyDeclLName, familyDeclName,

      -- * Grouping
      HsGroup(..),  emptyRdrGroup, emptyRnGroup, appendGroups, hsGroupInstDecls,
      hsGroupTopLevelFixitySigs,

      partitionBindsAndSigs,
        ) where

    -- friends:
    import GHC.Prelude

    import Language.Haskell.Syntax.Decls

    import {-# SOURCE #-} GHC.Hs.Expr ( pprExpr, pprUntypedSplice )
            -- Because Expr imports Decls via HsBracket

    import GHC.Hs.Binds
    import GHC.Hs.Type
    import GHC.Hs.Doc
    import GHC.Types.Basic
    import GHC.Core.Coercion
    import Language.Haskell.Syntax.Extension
    import GHC.Hs.Extension
    import GHC.Parser.Annotation
    import GHC.Types.Name
    import GHC.Types.Name.Set
    import GHC.Types.Fixity

    -- others:
    import GHC.Utils.Misc (count)
    import GHC.Utils.Outputable
    import GHC.Utils.Panic
    import GHC.Types.SrcLoc
    import GHC.Types.SourceText
    import GHC.Core.Type
    import GHC.Types.ForeignCall
    import GHC.Unit.Module.Warnings

    import GHC.Data.Maybe
    import Data.Data (Data)
    import Data.Foldable (toList)

    {-
    ************************************************************************
    *                                                                      *
    \subsection[HsDecl]{Declarations}
    *                                                                      *
    ************************************************************************
    -}

    type instance XTyClD      (GhcPass _) = NoExtField
    type instance XInstD      (GhcPass _) = NoExtField
    type instance XDerivD     (GhcPass _) = NoExtField
    type instance XValD       (GhcPass _) = NoExtField
    type instance XSigD       (GhcPass _) = NoExtField
    type instance XKindSigD   (GhcPass _) = NoExtField
    type instance XDefD       (GhcPass _) = NoExtField
    type instance XForD       (GhcPass _) = NoExtField
    type instance XWarningD   (GhcPass _) = NoExtField
    type instance XAnnD       (GhcPass _) = NoExtField
    type instance XRuleD      (GhcPass _) = NoExtField
    type instance XSpliceD    (GhcPass _) = NoExtField
    type instance XDocD       (GhcPass _) = NoExtField
    type instance XRoleAnnotD (GhcPass _) = NoExtField
    type instance XXHsDecl    (GhcPass _) = DataConCantHappen

    -- | Partition a list of HsDecls into function/pattern bindings, signatures,
    -- type family declarations, type family instances, and documentation comments.
    --
    -- Panics when given a declaration that cannot be put into any of the output
    -- groups.
    --
    -- The primary use of this function is to implement
    -- 'GHC.Parser.PostProcess.cvBindsAndSigs'.
    partitionBindsAndSigs
      :: [LHsDecl GhcPs]
      -> (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs],
          [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs])
    partitionBindsAndSigs :: [LHsDecl GhcPs]
    -> (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs],
        [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs])
    partitionBindsAndSigs = [LHsDecl GhcPs]
    -> (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs],
        [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs])
    [GenLocated SrcSpanAnnA (HsDecl GhcPs)]
    -> ([GenLocated SrcSpanAnnA (HsBind GhcPs)],
        [GenLocated SrcSpanAnnA (Sig GhcPs)],
        [GenLocated SrcSpanAnnA (FamilyDecl GhcPs)],
        [GenLocated SrcSpanAnnA (TyFamInstDecl GhcPs)],
        [GenLocated SrcSpanAnnA (DataFamInstDecl GhcPs)],
        [GenLocated SrcSpanAnnA (DocDecl GhcPs)])
    forall {p} {l}.
    Outputable (HsDecl p) =>
    [GenLocated l (HsDecl p)]
    -> ([GenLocated l (HsBind p)], [GenLocated l (Sig p)],
        [GenLocated l (FamilyDecl p)], [GenLocated l (TyFamInstDecl p)],
        [GenLocated l (DataFamInstDecl p)], [GenLocated l (DocDecl p)])
    go
      where
        go :: [GenLocated l (HsDecl p)]
    -> ([GenLocated l (HsBind p)], [GenLocated l (Sig p)],
        [GenLocated l (FamilyDecl p)], [GenLocated l (TyFamInstDecl p)],
        [GenLocated l (DataFamInstDecl p)], [GenLocated l (DocDecl p)])
    go [] = ([], [], [], [], [], [])
        go ((L l
    l HsDecl p
    decl) : [GenLocated l (HsDecl p)]
    ds) =
          let ([GenLocated l (HsBind p)]
    bs, [GenLocated l (Sig p)]
    ss, [GenLocated l (FamilyDecl p)]
    ts, [GenLocated l (TyFamInstDecl p)]
    tfis, [GenLocated l (DataFamInstDecl p)]
    dfis, [GenLocated l (DocDecl p)]
    docs) = [GenLocated l (HsDecl p)]
    -> ([GenLocated l (HsBind p)], [GenLocated l (Sig p)],
        [GenLocated l (FamilyDecl p)], [GenLocated l (TyFamInstDecl p)],
        [GenLocated l (DataFamInstDecl p)], [GenLocated l (DocDecl p)])
    go [GenLocated l (HsDecl p)]
    ds in
          case HsDecl p
    decl of
            ValD XValD p
    _ HsBind p
    b
              -> (l -> HsBind p -> GenLocated l (HsBind p)
    forall l e. l -> e -> GenLocated l e
    L l
    l HsBind p
    b GenLocated l (HsBind p)
    -> [GenLocated l (HsBind p)] -> [GenLocated l (HsBind p)]
    forall a. a -> [a] -> [a]
    : [GenLocated l (HsBind p)]
    bs, [GenLocated l (Sig p)]
    ss, [GenLocated l (FamilyDecl p)]
    ts, [GenLocated l (TyFamInstDecl p)]
    tfis, [GenLocated l (DataFamInstDecl p)]
    dfis, [GenLocated l (DocDecl p)]
    docs)
            SigD XSigD p
    _ Sig p
    s
              -> ([GenLocated l (HsBind p)]
    bs, l -> Sig p -> GenLocated l (Sig p)
    forall l e. l -> e -> GenLocated l e
    L l
    l Sig p
    s GenLocated l (Sig p)
    -> [GenLocated l (Sig p)] -> [GenLocated l (Sig p)]
    forall a. a -> [a] -> [a]
    : [GenLocated l (Sig p)]
    ss, [GenLocated l (FamilyDecl p)]
    ts, [GenLocated l (TyFamInstDecl p)]
    tfis, [GenLocated l (DataFamInstDecl p)]
    dfis, [GenLocated l (DocDecl p)]
    docs)
            TyClD XTyClD p
    _ (FamDecl XFamDecl p
    _ FamilyDecl p
    t)
              -> ([GenLocated l (HsBind p)]
    bs, [GenLocated l (Sig p)]
    ss, l -> FamilyDecl p -> GenLocated l (FamilyDecl p)
    forall l e. l -> e -> GenLocated l e
    L l
    l FamilyDecl p
    t GenLocated l (FamilyDecl p)
    -> [GenLocated l (FamilyDecl p)] -> [GenLocated l (FamilyDecl p)]
    forall a. a -> [a] -> [a]
    : [GenLocated l (FamilyDecl p)]
    ts, [GenLocated l (TyFamInstDecl p)]
    tfis, [GenLocated l (DataFamInstDecl p)]
    dfis, [GenLocated l (DocDecl p)]
    docs)
            InstD XInstD p
    _ (TyFamInstD { tfid_inst :: forall pass. InstDecl pass -> TyFamInstDecl pass
    tfid_inst = TyFamInstDecl p
    tfi })
              -> ([GenLocated l (HsBind p)]
    bs, [GenLocated l (Sig p)]
    ss, [GenLocated l (FamilyDecl p)]
    ts, l -> TyFamInstDecl p -> GenLocated l (TyFamInstDecl p)
    forall l e. l -> e -> GenLocated l e
    L l
    l TyFamInstDecl p
    tfi GenLocated l (TyFamInstDecl p)
    -> [GenLocated l (TyFamInstDecl p)]
    -> [GenLocated l (TyFamInstDecl p)]
    forall a. a -> [a] -> [a]
    : [GenLocated l (TyFamInstDecl p)]
    tfis, [GenLocated l (DataFamInstDecl p)]
    dfis, [GenLocated l (DocDecl p)]
    docs)
            InstD XInstD p
    _ (DataFamInstD { dfid_inst :: forall pass. InstDecl pass -> DataFamInstDecl pass
    dfid_inst = DataFamInstDecl p
    dfi })
              -> ([GenLocated l (HsBind p)]
    bs, [GenLocated l (Sig p)]
    ss, [GenLocated l (FamilyDecl p)]
    ts, [GenLocated l (TyFamInstDecl p)]
    tfis, l -> DataFamInstDecl p -> GenLocated l (DataFamInstDecl p)
    forall l e. l -> e -> GenLocated l e
    L l
    l DataFamInstDecl p
    dfi GenLocated l (DataFamInstDecl p)
    -> [GenLocated l (DataFamInstDecl p)]
    -> [GenLocated l (DataFamInstDecl p)]
    forall a. a -> [a] -> [a]
    : [GenLocated l (DataFamInstDecl p)]
    dfis, [GenLocated l (DocDecl p)]
    docs)
            DocD XDocD p
    _ DocDecl p
    d
              -> ([GenLocated l (HsBind p)]
    bs, [GenLocated l (Sig p)]
    ss, [GenLocated l (FamilyDecl p)]
    ts, [GenLocated l (TyFamInstDecl p)]
    tfis, [GenLocated l (DataFamInstDecl p)]
    dfis, l -> DocDecl p -> GenLocated l (DocDecl p)
    forall l e. l -> e -> GenLocated l e
    L l
    l DocDecl p
    d GenLocated l (DocDecl p)
    -> [GenLocated l (DocDecl p)] -> [GenLocated l (DocDecl p)]
    forall a. a -> [a] -> [a]
    : [GenLocated l (DocDecl p)]
    docs)
            HsDecl p
    _ -> String
    -> SDoc
    -> ([GenLocated l (HsBind p)], [GenLocated l (Sig p)],
        [GenLocated l (FamilyDecl p)], [GenLocated l (TyFamInstDecl p)],
        [GenLocated l (DataFamInstDecl p)], [GenLocated l (DocDecl p)])
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "partitionBindsAndSigs" (HsDecl p -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsDecl p
    decl)

    -- Okay, I need to reconstruct the document comments, but for now:
    instance Outputable (DocDecl name) where
      ppr :: DocDecl name -> SDoc
    ppr DocDecl name
    _ = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "<document comment>"

    type instance XCHsGroup (GhcPass _) = NoExtField
    type instance XXHsGroup (GhcPass _) = DataConCantHappen

    emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup (GhcPass p)
    emptyRdrGroup :: forall (p :: Pass). HsGroup (GhcPass p)
    emptyRdrGroup = HsGroup (GhcPass p)
    forall (p :: Pass). HsGroup (GhcPass p)
    emptyGroup { hs_valds = emptyValBindsIn }
    emptyRnGroup :: forall (p :: Pass). HsGroup (GhcPass p)
    emptyRnGroup  = HsGroup (GhcPass p)
    forall (p :: Pass). HsGroup (GhcPass p)
    emptyGroup { hs_valds = emptyValBindsOut }

    emptyGroup :: forall (p :: Pass). HsGroup (GhcPass p)
    emptyGroup = HsGroup { hs_ext :: XCHsGroup (GhcPass p)
    hs_ext = XCHsGroup (GhcPass p)
    NoExtField
    noExtField,
                           hs_tyclds :: [TyClGroup (GhcPass p)]
    hs_tyclds = [],
                           hs_derivds :: [LDerivDecl (GhcPass p)]
    hs_derivds = [],
                           hs_fixds :: [LFixitySig (GhcPass p)]
    hs_fixds = [], hs_defds :: [LDefaultDecl (GhcPass p)]
    hs_defds = [], hs_annds :: [LAnnDecl (GhcPass p)]
    hs_annds = [],
                           hs_fords :: [LForeignDecl (GhcPass p)]
    hs_fords = [], hs_warnds :: [LWarnDecls (GhcPass p)]
    hs_warnds = [], hs_ruleds :: [LRuleDecls (GhcPass p)]
    hs_ruleds = [],
                           hs_valds :: HsValBinds (GhcPass p)
    hs_valds = String -> HsValBinds (GhcPass p)
    forall a. HasCallStack => String -> a
    error String
    "emptyGroup hs_valds: Can't happen",
                           hs_splcds :: [LSpliceDecl (GhcPass p)]
    hs_splcds = [],
                           hs_docs :: [LDocDecl (GhcPass p)]
    hs_docs = [] }

    -- | The fixity signatures for each top-level declaration and class method
    -- in an 'HsGroup'.
    -- See Note [Top-level fixity signatures in an HsGroup]
    hsGroupTopLevelFixitySigs :: HsGroup (GhcPass p) -> [LFixitySig (GhcPass p)]
    hsGroupTopLevelFixitySigs :: forall (p :: Pass). HsGroup (GhcPass p) -> [LFixitySig (GhcPass p)]
    hsGroupTopLevelFixitySigs (HsGroup{ hs_fixds :: forall p. HsGroup p -> [LFixitySig p]
    hs_fixds = [LFixitySig (GhcPass p)]
    fixds, hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup (GhcPass p)]
    tyclds }) =
        [LFixitySig (GhcPass p)]
    [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    fixds [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    cls_fixds
      where
        cls_fixds :: [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    cls_fixds = [ SrcSpanAnnA
    -> FixitySig (GhcPass p)
    -> GenLocated SrcSpanAnnA (FixitySig (GhcPass p))
    forall l e. l -> e -> GenLocated l e
    L SrcSpanAnnA
    loc FixitySig (GhcPass p)
    sig
                    | L SrcSpanAnnA
    _ ClassDecl{tcdSigs :: forall pass. TyClDecl pass -> [LSig pass]
    tcdSigs = [LSig (GhcPass p)]
    sigs} <- [TyClGroup (GhcPass p)] -> [LTyClDecl (GhcPass p)]
    forall pass. [TyClGroup pass] -> [LTyClDecl pass]
    tyClGroupTyClDecls [TyClGroup (GhcPass p)]
    tyclds
                    , L SrcSpanAnnA
    loc (FixSig XFixSig (GhcPass p)
    _ FixitySig (GhcPass p)
    sig) <- [LSig (GhcPass p)]
    [GenLocated SrcSpanAnnA (Sig (GhcPass p))]
    sigs
                    ]

    appendGroups :: HsGroup (GhcPass p) -> HsGroup (GhcPass p)
                 -> HsGroup (GhcPass p)
    appendGroups :: forall (p :: Pass).
    HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p)
    appendGroups
        HsGroup {
            hs_valds :: forall p. HsGroup p -> HsValBinds p
    hs_valds  = HsValBinds (GhcPass p)
    val_groups1,
            hs_splcds :: forall p. HsGroup p -> [LSpliceDecl p]
    hs_splcds = [LSpliceDecl (GhcPass p)]
    spliceds1,
            hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup (GhcPass p)]
    tyclds1,
            hs_derivds :: forall p. HsGroup p -> [LDerivDecl p]
    hs_derivds = [LDerivDecl (GhcPass p)]
    derivds1,
            hs_fixds :: forall p. HsGroup p -> [LFixitySig p]
    hs_fixds  = [LFixitySig (GhcPass p)]
    fixds1,
            hs_defds :: forall p. HsGroup p -> [LDefaultDecl p]
    hs_defds  = [LDefaultDecl (GhcPass p)]
    defds1,
            hs_annds :: forall p. HsGroup p -> [LAnnDecl p]
    hs_annds  = [LAnnDecl (GhcPass p)]
    annds1,
            hs_fords :: forall p. HsGroup p -> [LForeignDecl p]
    hs_fords  = [LForeignDecl (GhcPass p)]
    fords1,
            hs_warnds :: forall p. HsGroup p -> [LWarnDecls p]
    hs_warnds = [LWarnDecls (GhcPass p)]
    warnds1,
            hs_ruleds :: forall p. HsGroup p -> [LRuleDecls p]
    hs_ruleds = [LRuleDecls (GhcPass p)]
    rulds1,
            hs_docs :: forall p. HsGroup p -> [LDocDecl p]
    hs_docs   = [LDocDecl (GhcPass p)]
    docs1 }
        HsGroup {
            hs_valds :: forall p. HsGroup p -> HsValBinds p
    hs_valds  = HsValBinds (GhcPass p)
    val_groups2,
            hs_splcds :: forall p. HsGroup p -> [LSpliceDecl p]
    hs_splcds = [LSpliceDecl (GhcPass p)]
    spliceds2,
            hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup (GhcPass p)]
    tyclds2,
            hs_derivds :: forall p. HsGroup p -> [LDerivDecl p]
    hs_derivds = [LDerivDecl (GhcPass p)]
    derivds2,
            hs_fixds :: forall p. HsGroup p -> [LFixitySig p]
    hs_fixds  = [LFixitySig (GhcPass p)]
    fixds2,
            hs_defds :: forall p. HsGroup p -> [LDefaultDecl p]
    hs_defds  = [LDefaultDecl (GhcPass p)]
    defds2,
            hs_annds :: forall p. HsGroup p -> [LAnnDecl p]
    hs_annds  = [LAnnDecl (GhcPass p)]
    annds2,
            hs_fords :: forall p. HsGroup p -> [LForeignDecl p]
    hs_fords  = [LForeignDecl (GhcPass p)]
    fords2,
            hs_warnds :: forall p. HsGroup p -> [LWarnDecls p]
    hs_warnds = [LWarnDecls (GhcPass p)]
    warnds2,
            hs_ruleds :: forall p. HsGroup p -> [LRuleDecls p]
    hs_ruleds = [LRuleDecls (GhcPass p)]
    rulds2,
            hs_docs :: forall p. HsGroup p -> [LDocDecl p]
    hs_docs   = [LDocDecl (GhcPass p)]
    docs2 }
      =
        HsGroup {
            hs_ext :: XCHsGroup (GhcPass p)
    hs_ext    = XCHsGroup (GhcPass p)
    NoExtField
    noExtField,
            hs_valds :: HsValBinds (GhcPass p)
    hs_valds  = HsValBinds (GhcPass p)
    val_groups1 HsValBinds (GhcPass p)
    -> HsValBinds (GhcPass p) -> HsValBinds (GhcPass p)
    forall (a :: Pass).
    HsValBinds (GhcPass a)
    -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a)
    `plusHsValBinds` HsValBinds (GhcPass p)
    val_groups2,
            hs_splcds :: [LSpliceDecl (GhcPass p)]
    hs_splcds = [LSpliceDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (SpliceDecl (GhcPass p))]
    spliceds1 [GenLocated SrcSpanAnnA (SpliceDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (SpliceDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (SpliceDecl (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LSpliceDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (SpliceDecl (GhcPass p))]
    spliceds2,
            hs_tyclds :: [TyClGroup (GhcPass p)]
    hs_tyclds = [TyClGroup (GhcPass p)]
    tyclds1 [TyClGroup (GhcPass p)]
    -> [TyClGroup (GhcPass p)] -> [TyClGroup (GhcPass p)]
    forall a. [a] -> [a] -> [a]
    ++ [TyClGroup (GhcPass p)]
    tyclds2,
            hs_derivds :: [LDerivDecl (GhcPass p)]
    hs_derivds = [LDerivDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))]
    derivds1 [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LDerivDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))]
    derivds2,
            hs_fixds :: [LFixitySig (GhcPass p)]
    hs_fixds  = [LFixitySig (GhcPass p)]
    [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    fixds1 [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LFixitySig (GhcPass p)]
    [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    fixds2,
            hs_annds :: [LAnnDecl (GhcPass p)]
    hs_annds  = [LAnnDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))]
    annds1 [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LAnnDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))]
    annds2,
            hs_defds :: [LDefaultDecl (GhcPass p)]
    hs_defds  = [LDefaultDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))]
    defds1 [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LDefaultDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))]
    defds2,
            hs_fords :: [LForeignDecl (GhcPass p)]
    hs_fords  = [LForeignDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))]
    fords1 [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LForeignDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))]
    fords2,
            hs_warnds :: [LWarnDecls (GhcPass p)]
    hs_warnds = [LWarnDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))]
    warnds1 [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LWarnDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))]
    warnds2,
            hs_ruleds :: [LRuleDecls (GhcPass p)]
    hs_ruleds = [LRuleDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    rulds1 [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LRuleDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    rulds2,
            hs_docs :: [LDocDecl (GhcPass p)]
    hs_docs   = [LDocDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DocDecl (GhcPass p))]
    docs1  [GenLocated SrcSpanAnnA (DocDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (DocDecl (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (DocDecl (GhcPass p))]
    forall a. [a] -> [a] -> [a]
    ++ [LDocDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DocDecl (GhcPass p))]
    docs2 }

    instance (OutputableBndrId p) => Outputable (HsDecl (GhcPass p)) where
        ppr :: HsDecl (GhcPass p) -> SDoc
    ppr (TyClD XTyClD (GhcPass p)
    _ TyClDecl (GhcPass p)
    dcl)             = TyClDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyClDecl (GhcPass p)
    dcl
        ppr (ValD XValD (GhcPass p)
    _ HsBind (GhcPass p)
    binds)            = HsBind (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsBind (GhcPass p)
    binds
        ppr (DefD XDefD (GhcPass p)
    _ DefaultDecl (GhcPass p)
    def)              = DefaultDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DefaultDecl (GhcPass p)
    def
        ppr (InstD XInstD (GhcPass p)
    _ InstDecl (GhcPass p)
    inst)            = InstDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr InstDecl (GhcPass p)
    inst
        ppr (DerivD XDerivD (GhcPass p)
    _ DerivDecl (GhcPass p)
    deriv)          = DerivDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DerivDecl (GhcPass p)
    deriv
        ppr (ForD XForD (GhcPass p)
    _ ForeignDecl (GhcPass p)
    fd)               = ForeignDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ForeignDecl (GhcPass p)
    fd
        ppr (SigD XSigD (GhcPass p)
    _ Sig (GhcPass p)
    sd)               = Sig (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Sig (GhcPass p)
    sd
        ppr (KindSigD XKindSigD (GhcPass p)
    _ StandaloneKindSig (GhcPass p)
    ksd)          = StandaloneKindSig (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr StandaloneKindSig (GhcPass p)
    ksd
        ppr (RuleD XRuleD (GhcPass p)
    _ RuleDecls (GhcPass p)
    rd)              = RuleDecls (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RuleDecls (GhcPass p)
    rd
        ppr (WarningD XWarningD (GhcPass p)
    _ WarnDecls (GhcPass p)
    wd)           = WarnDecls (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr WarnDecls (GhcPass p)
    wd
        ppr (AnnD XAnnD (GhcPass p)
    _ AnnDecl (GhcPass p)
    ad)               = AnnDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr AnnDecl (GhcPass p)
    ad
        ppr (SpliceD XSpliceD (GhcPass p)
    _ SpliceDecl (GhcPass p)
    dd)            = SpliceDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr SpliceDecl (GhcPass p)
    dd
        ppr (DocD XDocD (GhcPass p)
    _ DocDecl (GhcPass p)
    doc)              = DocDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DocDecl (GhcPass p)
    doc
        ppr (RoleAnnotD XRoleAnnotD (GhcPass p)
    _ RoleAnnotDecl (GhcPass p)
    ra)         = RoleAnnotDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RoleAnnotDecl (GhcPass p)
    ra

    instance (OutputableBndrId p) => Outputable (HsGroup (GhcPass p)) where
        ppr :: HsGroup (GhcPass p) -> SDoc
    ppr (HsGroup { hs_valds :: forall p. HsGroup p -> HsValBinds p
    hs_valds  = HsValBinds (GhcPass p)
    val_decls,
                       hs_tyclds :: forall p. HsGroup p -> [TyClGroup p]
    hs_tyclds = [TyClGroup (GhcPass p)]
    tycl_decls,
                       hs_derivds :: forall p. HsGroup p -> [LDerivDecl p]
    hs_derivds = [LDerivDecl (GhcPass p)]
    deriv_decls,
                       hs_fixds :: forall p. HsGroup p -> [LFixitySig p]
    hs_fixds  = [LFixitySig (GhcPass p)]
    fix_decls,
                       hs_warnds :: forall p. HsGroup p -> [LWarnDecls p]
    hs_warnds = [LWarnDecls (GhcPass p)]
    deprec_decls,
                       hs_annds :: forall p. HsGroup p -> [LAnnDecl p]
    hs_annds  = [LAnnDecl (GhcPass p)]
    ann_decls,
                       hs_fords :: forall p. HsGroup p -> [LForeignDecl p]
    hs_fords  = [LForeignDecl (GhcPass p)]
    foreign_decls,
                       hs_defds :: forall p. HsGroup p -> [LDefaultDecl p]
    hs_defds  = [LDefaultDecl (GhcPass p)]
    default_decls,
                       hs_ruleds :: forall p. HsGroup p -> [LRuleDecls p]
    hs_ruleds = [LRuleDecls (GhcPass p)]
    rule_decls })
            = SDoc -> [Maybe SDoc] -> SDoc
    vcat_mb SDoc
    forall doc. IsOutput doc => doc
    empty
                [[GenLocated SrcSpanAnnA (FixitySig (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LFixitySig (GhcPass p)]
    [GenLocated SrcSpanAnnA (FixitySig (GhcPass p))]
    fix_decls, [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LDefaultDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DefaultDecl (GhcPass p))]
    default_decls,
                 [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LWarnDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (WarnDecls (GhcPass p))]
    deprec_decls, [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LAnnDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (AnnDecl (GhcPass p))]
    ann_decls,
                 [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LRuleDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    rule_decls,
                 if HsValBinds (GhcPass p) -> Bool
    forall (a :: Pass) (b :: Pass).
    HsValBindsLR (GhcPass a) (GhcPass b) -> Bool
    isEmptyValBinds HsValBinds (GhcPass p)
    val_decls
                    then Maybe SDoc
    forall a. Maybe a
    Nothing
                    else SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just (HsValBinds (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsValBinds (GhcPass p)
    val_decls),
                 [GenLocated SrcSpanAnnA (RoleAnnotDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds ([TyClGroup (GhcPass p)] -> [LRoleAnnotDecl (GhcPass p)]
    forall pass. [TyClGroup pass] -> [LRoleAnnotDecl pass]
    tyClGroupRoleDecls [TyClGroup (GhcPass p)]
    tycl_decls),
                 [GenLocated SrcSpanAnnA (StandaloneKindSig (GhcPass p))]
    -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds ([TyClGroup (GhcPass p)] -> [LStandaloneKindSig (GhcPass p)]
    forall pass. [TyClGroup pass] -> [LStandaloneKindSig pass]
    tyClGroupKindSigs  [TyClGroup (GhcPass p)]
    tycl_decls),
                 [GenLocated SrcSpanAnnA (TyClDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds ([TyClGroup (GhcPass p)] -> [LTyClDecl (GhcPass p)]
    forall pass. [TyClGroup pass] -> [LTyClDecl pass]
    tyClGroupTyClDecls [TyClGroup (GhcPass p)]
    tycl_decls),
                 [GenLocated SrcSpanAnnA (InstDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds ([TyClGroup (GhcPass p)] -> [LInstDecl (GhcPass p)]
    forall pass. [TyClGroup pass] -> [LInstDecl pass]
    tyClGroupInstDecls [TyClGroup (GhcPass p)]
    tycl_decls),
                 [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LDerivDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DerivDecl (GhcPass p))]
    deriv_decls,
                 [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))] -> Maybe SDoc
    forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [LForeignDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (ForeignDecl (GhcPass p))]
    foreign_decls]
            where
              ppr_ds :: Outputable a => [a] -> Maybe SDoc
              ppr_ds :: forall a. Outputable a => [a] -> Maybe SDoc
    ppr_ds [] = Maybe SDoc
    forall a. Maybe a
    Nothing
              ppr_ds [a]
    ds = SDoc -> Maybe SDoc
    forall a. a -> Maybe a
    Just ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat ((a -> SDoc) -> [a] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [a]
    ds))

              vcat_mb :: SDoc -> [Maybe SDoc] -> SDoc
              -- Concatenate vertically with white-space between non-blanks
              vcat_mb :: SDoc -> [Maybe SDoc] -> SDoc
    vcat_mb SDoc
    _    []             = SDoc
    forall doc. IsOutput doc => doc
    empty
              vcat_mb SDoc
    gap (Maybe SDoc
    Nothing : [Maybe SDoc]
    ds) = SDoc -> [Maybe SDoc] -> SDoc
    vcat_mb SDoc
    gap [Maybe SDoc]
    ds
              vcat_mb SDoc
    gap (Just SDoc
    d  : [Maybe SDoc]
    ds) = SDoc
    gap SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ SDoc
    d SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ SDoc -> [Maybe SDoc] -> SDoc
    vcat_mb SDoc
    blankLine [Maybe SDoc]
    ds

    type instance XSpliceDecl      (GhcPass _) = NoExtField
    type instance XXSpliceDecl     (GhcPass _) = DataConCantHappen

    instance OutputableBndrId p
           => Outputable (SpliceDecl (GhcPass p)) where
      ppr :: SpliceDecl (GhcPass p) -> SDoc
    ppr (SpliceDecl XSpliceDecl (GhcPass p)
    _ (L Anno (HsUntypedSplice (GhcPass p))
    _ HsUntypedSplice (GhcPass p)
    e) SpliceDecoration
    DollarSplice) = Bool
    -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Bool
    -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
    pprUntypedSplice Bool
    True Maybe SplicePointName
    forall a. Maybe a
    Nothing HsUntypedSplice (GhcPass p)
    e
      ppr (SpliceDecl XSpliceDecl (GhcPass p)
    _ (L Anno (HsUntypedSplice (GhcPass p))
    _ HsUntypedSplice (GhcPass p)
    e) SpliceDecoration
    BareSplice)   = Bool
    -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Bool
    -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
    pprUntypedSplice Bool
    False Maybe SplicePointName
    forall a. Maybe a
    Nothing HsUntypedSplice (GhcPass p)
    e

    instance Outputable SpliceDecoration where
      ppr :: SpliceDecoration -> SDoc
    ppr SpliceDecoration
    x = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (String -> SDoc) -> String -> SDoc
    forall a b. (a -> b) -> a -> b
    $ SpliceDecoration -> String
    forall a. Show a => a -> String
    show SpliceDecoration
    x

    {-
    ************************************************************************
    *                                                                      *
                Type and class declarations
    *                                                                      *
    ************************************************************************
    -}

    type instance XFamDecl      (GhcPass _) = NoExtField

    type instance XSynDecl      GhcPs = AnnSynDecl
    type instance XSynDecl      GhcRn = NameSet -- FVs
    type instance XSynDecl      GhcTc = NameSet -- FVs

    type instance XDataDecl     GhcPs = NoExtField
    type instance XDataDecl     GhcRn = DataDeclRn
    type instance XDataDecl     GhcTc = DataDeclRn

    data DataDeclRn = DataDeclRn
                 { DataDeclRn -> Bool
    tcdDataCusk :: Bool    -- ^ does this have a CUSK?
                     -- See Note [CUSKs: complete user-supplied kind signatures]
                 , DataDeclRn -> NameSet
    tcdFVs      :: NameSet }
      deriving Typeable DataDeclRn
    Typeable DataDeclRn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DataDeclRn)
    -> (DataDeclRn -> Constr)
    -> (DataDeclRn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c DataDeclRn))
    -> ((forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DataDeclRn -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn)
    -> Data DataDeclRn
    DataDeclRn -> Constr
    DataDeclRn -> DataType
    (forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u
    forall u. (forall d. Data d => d -> u) -> DataDeclRn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataDeclRn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDeclRn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataDeclRn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataDeclRn
    $ctoConstr :: DataDeclRn -> Constr
    toConstr :: DataDeclRn -> Constr
    $cdataTypeOf :: DataDeclRn -> DataType
    dataTypeOf :: DataDeclRn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDeclRn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDeclRn)
    $cgmapT :: (forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn
    gmapT :: (forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataDeclRn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DataDeclRn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn
    Data

    type instance XClassDecl    GhcPs =
      ( AnnClassDecl
      , EpLayout              -- See Note [Class EpLayout]
      , AnnSortKey DeclTag )  -- TODO:AZ:tidy up AnnSortKey

    type instance XClassDecl    GhcRn = NameSet -- FVs
    type instance XClassDecl    GhcTc = NameSet -- FVs

    type instance XXTyClDecl    (GhcPass _) = DataConCantHappen

    type instance XCTyFamInstDecl (GhcPass _) = (EpToken "type", EpToken "instance")
    type instance XXTyFamInstDecl (GhcPass _) = DataConCantHappen

    data AnnDataDefn
      = AnnDataDefn {
          AnnDataDefn -> [EpToken "("]
    andd_openp    :: [EpToken "("],
          AnnDataDefn -> [EpToken ")"]
    andd_closep   :: [EpToken ")"],
          AnnDataDefn -> EpToken "type"
    andd_type     :: EpToken "type",
          AnnDataDefn -> EpToken "newtype"
    andd_newtype  :: EpToken "newtype",
          AnnDataDefn -> EpToken "data"
    andd_data     :: EpToken "data",
          AnnDataDefn -> EpToken "instance"
    andd_instance :: EpToken "instance",
          AnnDataDefn -> TokDcolon
    andd_dcolon   :: TokDcolon,
          AnnDataDefn -> EpToken "where"
    andd_where    :: EpToken "where",
          AnnDataDefn -> EpToken "{"
    andd_openc    :: EpToken "{",
          AnnDataDefn -> EpToken "}"
    andd_closec   :: EpToken "}",
          AnnDataDefn -> EpToken "="
    andd_equal    :: EpToken "="
      } deriving Typeable AnnDataDefn
    Typeable AnnDataDefn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnDataDefn -> c AnnDataDefn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnDataDefn)
    -> (AnnDataDefn -> Constr)
    -> (AnnDataDefn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnDataDefn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnDataDefn))
    -> ((forall b. Data b => b -> b) -> AnnDataDefn -> AnnDataDefn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnDataDefn -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnDataDefn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn)
    -> Data AnnDataDefn
    AnnDataDefn -> Constr
    AnnDataDefn -> DataType
    (forall b. Data b => b -> b) -> AnnDataDefn -> AnnDataDefn
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> AnnDataDefn -> u
    forall u. (forall d. Data d => d -> u) -> AnnDataDefn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnDataDefn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnDataDefn -> c AnnDataDefn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnDataDefn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnDataDefn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnDataDefn -> c AnnDataDefn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnDataDefn -> c AnnDataDefn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnDataDefn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnDataDefn
    $ctoConstr :: AnnDataDefn -> Constr
    toConstr :: AnnDataDefn -> Constr
    $cdataTypeOf :: AnnDataDefn -> DataType
    dataTypeOf :: AnnDataDefn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnDataDefn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnDataDefn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnDataDefn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnDataDefn)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnDataDefn -> AnnDataDefn
    gmapT :: (forall b. Data b => b -> b) -> AnnDataDefn -> AnnDataDefn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnDataDefn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnDataDefn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnDataDefn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnDataDefn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnDataDefn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnDataDefn -> m AnnDataDefn
    Data

    instance NoAnn AnnDataDefn where
      noAnn :: AnnDataDefn
    noAnn = [EpToken "("]
    -> [EpToken ")"]
    -> EpToken "type"
    -> EpToken "newtype"
    -> EpToken "data"
    -> EpToken "instance"
    -> TokDcolon
    -> EpToken "where"
    -> EpToken "{"
    -> EpToken "}"
    -> EpToken "="
    -> AnnDataDefn
    AnnDataDefn [EpToken "("]
    forall a. NoAnn a => a
    noAnn [EpToken ")"]
    forall a. NoAnn a => a
    noAnn EpToken "type"
    forall a. NoAnn a => a
    noAnn EpToken "newtype"
    forall a. NoAnn a => a
    noAnn EpToken "data"
    forall a. NoAnn a => a
    noAnn EpToken "instance"
    forall a. NoAnn a => a
    noAnn TokDcolon
    forall a. NoAnn a => a
    noAnn EpToken "where"
    forall a. NoAnn a => a
    noAnn EpToken "{"
    forall a. NoAnn a => a
    noAnn EpToken "}"
    forall a. NoAnn a => a
    noAnn EpToken "="
    forall a. NoAnn a => a
    noAnn

    data AnnClassDecl
      = AnnClassDecl {
          AnnClassDecl -> EpToken "class"
    acd_class  :: EpToken "class",
          AnnClassDecl -> [EpToken "("]
    acd_openp  :: [EpToken "("],
          AnnClassDecl -> [EpToken ")"]
    acd_closep :: [EpToken ")"],
          AnnClassDecl -> EpToken "|"
    acd_vbar   :: EpToken "|",
          AnnClassDecl -> EpToken "where"
    acd_where  :: EpToken "where",
          AnnClassDecl -> EpToken "{"
    acd_openc  :: EpToken "{",
          AnnClassDecl -> EpToken "}"
    acd_closec :: EpToken "}",
          AnnClassDecl -> [EpToken ";"]
    acd_semis  :: [EpToken ";"]
      } deriving Typeable AnnClassDecl
    Typeable AnnClassDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnClassDecl -> c AnnClassDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnClassDecl)
    -> (AnnClassDecl -> Constr)
    -> (AnnClassDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnClassDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnClassDecl))
    -> ((forall b. Data b => b -> b) -> AnnClassDecl -> AnnClassDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnClassDecl -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnClassDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl)
    -> Data AnnClassDecl
    AnnClassDecl -> Constr
    AnnClassDecl -> DataType
    (forall b. Data b => b -> b) -> AnnClassDecl -> AnnClassDecl
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> AnnClassDecl -> u
    forall u. (forall d. Data d => d -> u) -> AnnClassDecl -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnClassDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnClassDecl -> c AnnClassDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnClassDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnClassDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnClassDecl -> c AnnClassDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnClassDecl -> c AnnClassDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnClassDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnClassDecl
    $ctoConstr :: AnnClassDecl -> Constr
    toConstr :: AnnClassDecl -> Constr
    $cdataTypeOf :: AnnClassDecl -> DataType
    dataTypeOf :: AnnClassDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnClassDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnClassDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnClassDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnClassDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnClassDecl -> AnnClassDecl
    gmapT :: (forall b. Data b => b -> b) -> AnnClassDecl -> AnnClassDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClassDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnClassDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnClassDecl -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnClassDecl -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnClassDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnClassDecl -> m AnnClassDecl
    Data

    instance NoAnn AnnClassDecl where
      noAnn :: AnnClassDecl
    noAnn = EpToken "class"
    -> [EpToken "("]
    -> [EpToken ")"]
    -> EpToken "|"
    -> EpToken "where"
    -> EpToken "{"
    -> EpToken "}"
    -> [EpToken ";"]
    -> AnnClassDecl
    AnnClassDecl EpToken "class"
    forall a. NoAnn a => a
    noAnn [EpToken "("]
    forall a. NoAnn a => a
    noAnn [EpToken ")"]
    forall a. NoAnn a => a
    noAnn EpToken "|"
    forall a. NoAnn a => a
    noAnn EpToken "where"
    forall a. NoAnn a => a
    noAnn EpToken "{"
    forall a. NoAnn a => a
    noAnn EpToken "}"
    forall a. NoAnn a => a
    noAnn [EpToken ";"]
    forall a. NoAnn a => a
    noAnn

    data AnnSynDecl
      = AnnSynDecl {
        AnnSynDecl -> [EpToken "("]
    asd_opens  :: [EpToken "("],
        AnnSynDecl -> [EpToken ")"]
    asd_closes :: [EpToken ")"],
        AnnSynDecl -> EpToken "type"
    asd_type   :: EpToken "type",
        AnnSynDecl -> EpToken "="
    asd_equal  :: EpToken "="
      } deriving Typeable AnnSynDecl
    Typeable AnnSynDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnSynDecl -> c AnnSynDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnSynDecl)
    -> (AnnSynDecl -> Constr)
    -> (AnnSynDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnSynDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnSynDecl))
    -> ((forall b. Data b => b -> b) -> AnnSynDecl -> AnnSynDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnSynDecl -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnSynDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl)
    -> Data AnnSynDecl
    AnnSynDecl -> Constr
    AnnSynDecl -> DataType
    (forall b. Data b => b -> b) -> AnnSynDecl -> AnnSynDecl
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> AnnSynDecl -> u
    forall u. (forall d. Data d => d -> u) -> AnnSynDecl -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnSynDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSynDecl -> c AnnSynDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnSynDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnSynDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSynDecl -> c AnnSynDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSynDecl -> c AnnSynDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnSynDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnSynDecl
    $ctoConstr :: AnnSynDecl -> Constr
    toConstr :: AnnSynDecl -> Constr
    $cdataTypeOf :: AnnSynDecl -> DataType
    dataTypeOf :: AnnSynDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnSynDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnSynDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnSynDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnSynDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnSynDecl -> AnnSynDecl
    gmapT :: (forall b. Data b => b -> b) -> AnnSynDecl -> AnnSynDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSynDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnSynDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnSynDecl -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnSynDecl -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnSynDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnSynDecl -> m AnnSynDecl
    Data

    instance NoAnn AnnSynDecl where
      noAnn :: AnnSynDecl
    noAnn = [EpToken "("]
    -> [EpToken ")"] -> EpToken "type" -> EpToken "=" -> AnnSynDecl
    AnnSynDecl [EpToken "("]
    forall a. NoAnn a => a
    noAnn [EpToken ")"]
    forall a. NoAnn a => a
    noAnn EpToken "type"
    forall a. NoAnn a => a
    noAnn EpToken "="
    forall a. NoAnn a => a
    noAnn

    ------------- Pretty printing FamilyDecls -----------

    pprFlavour :: FamilyInfo pass -> SDoc
    pprFlavour :: forall pass. FamilyInfo pass -> SDoc
    pprFlavour FamilyInfo pass
    DataFamily            = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "data"
    pprFlavour FamilyInfo pass
    OpenTypeFamily        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type"
    pprFlavour (ClosedTypeFamily {}) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type"

    instance Outputable (FamilyInfo pass) where
      ppr :: FamilyInfo pass -> SDoc
    ppr FamilyInfo pass
    info = FamilyInfo pass -> SDoc
    forall pass. FamilyInfo pass -> SDoc
    pprFlavour FamilyInfo pass
    info SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "family"

    -- Dealing with names

    tyFamInstDeclName :: Anno (IdGhcP p) ~ SrcSpanAnnN
                      => TyFamInstDecl (GhcPass p) -> IdP (GhcPass p)
    tyFamInstDeclName :: forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyFamInstDecl (GhcPass p) -> IdP (GhcPass p)
    tyFamInstDeclName = GenLocated SrcSpanAnnN (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnN (IdGhcP p) -> IdGhcP p)
    -> (TyFamInstDecl (GhcPass p) -> GenLocated SrcSpanAnnN (IdGhcP p))
    -> TyFamInstDecl (GhcPass p)
    -> IdGhcP p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TyFamInstDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    TyFamInstDecl (GhcPass p) -> GenLocated SrcSpanAnnN (IdGhcP p)
    forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyFamInstDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    tyFamInstDeclLName

    tyFamInstDeclLName :: Anno (IdGhcP p) ~ SrcSpanAnnN
                       => TyFamInstDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    tyFamInstDeclLName :: forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyFamInstDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    tyFamInstDeclLName (TyFamInstDecl { tfid_eqn :: forall pass. TyFamInstDecl pass -> TyFamInstEqn pass
    tfid_eqn = FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> LIdP pass
    feqn_tycon = LIdP (GhcPass p)
    ln }})
      = LIdP (GhcPass p)
    GenLocated SrcSpanAnnN (IdP (GhcPass p))
    ln

    tyClDeclLName :: Anno (IdGhcP p) ~ SrcSpanAnnN
                  => TyClDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    tyClDeclLName :: forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyClDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    tyClDeclLName (FamDecl { tcdFam :: forall pass. TyClDecl pass -> FamilyDecl pass
    tcdFam = FamilyDecl (GhcPass p)
    fd })     = FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
    forall (p :: Pass).
    FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
    familyDeclLName FamilyDecl (GhcPass p)
    fd
    tyClDeclLName (SynDecl { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = XRec (GhcPass p) (IdP (GhcPass p))
    ln })   = XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated SrcSpanAnnN (IdP (GhcPass p))
    ln
    tyClDeclLName (DataDecl { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = XRec (GhcPass p) (IdP (GhcPass p))
    ln })  = XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated SrcSpanAnnN (IdP (GhcPass p))
    ln
    tyClDeclLName (ClassDecl { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = XRec (GhcPass p) (IdP (GhcPass p))
    ln }) = XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated SrcSpanAnnN (IdP (GhcPass p))
    ln

    countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
            -- class, synonym decls, data, newtype, family decls
    countTyClDecls :: forall pass. [TyClDecl pass] -> (Int, Int, Int, Int, Int)
    countTyClDecls [TyClDecl pass]
    decls
     = ((TyClDecl pass -> Bool) -> [TyClDecl pass] -> Int
    forall a. (a -> Bool) -> [a] -> Int
    count TyClDecl pass -> Bool
    forall pass. TyClDecl pass -> Bool
    isClassDecl    [TyClDecl pass]
    decls,
        (TyClDecl pass -> Bool) -> [TyClDecl pass] -> Int
    forall a. (a -> Bool) -> [a] -> Int
    count TyClDecl pass -> Bool
    forall pass. TyClDecl pass -> Bool
    isSynDecl      [TyClDecl pass]
    decls,  -- excluding...
        (TyClDecl pass -> Bool) -> [TyClDecl pass] -> Int
    forall a. (a -> Bool) -> [a] -> Int
    count TyClDecl pass -> Bool
    forall pass. TyClDecl pass -> Bool
    isDataTy       [TyClDecl pass]
    decls,  -- ...family...
        (TyClDecl pass -> Bool) -> [TyClDecl pass] -> Int
    forall a. (a -> Bool) -> [a] -> Int
    count TyClDecl pass -> Bool
    forall pass. TyClDecl pass -> Bool
    isNewTy        [TyClDecl pass]
    decls,  -- ...instances
        (TyClDecl pass -> Bool) -> [TyClDecl pass] -> Int
    forall a. (a -> Bool) -> [a] -> Int
    count TyClDecl pass -> Bool
    forall pass. TyClDecl pass -> Bool
    isFamilyDecl   [TyClDecl pass]
    decls)
     where
       isDataTy :: TyClDecl pass -> Bool
    isDataTy DataDecl{ tcdDataDefn :: forall pass. TyClDecl pass -> HsDataDefn pass
    tcdDataDefn = HsDataDefn { dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataTypeCons Bool
    _ [LConDecl pass]
    _ } } = Bool
    True
       isDataTy TyClDecl pass
    _                                                       = Bool
    False

       isNewTy :: TyClDecl pass -> Bool
    isNewTy DataDecl{ tcdDataDefn :: forall pass. TyClDecl pass -> HsDataDefn pass
    tcdDataDefn = HsDataDefn { dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = NewTypeCon LConDecl pass
    _ } } = Bool
    True
       isNewTy TyClDecl pass
    _                                                      = Bool
    False

    -- FIXME: tcdName is commonly used by both GHC and third-party tools, so it
    -- needs to be polymorphic in the pass
    tcdName :: Anno (IdGhcP p) ~ SrcSpanAnnN
            => TyClDecl (GhcPass p) -> IdP (GhcPass p)
    tcdName :: forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyClDecl (GhcPass p) -> IdP (GhcPass p)
    tcdName = GenLocated SrcSpanAnnN (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnN (IdGhcP p) -> IdGhcP p)
    -> (TyClDecl (GhcPass p) -> GenLocated SrcSpanAnnN (IdGhcP p))
    -> TyClDecl (GhcPass p)
    -> IdGhcP p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TyClDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    TyClDecl (GhcPass p) -> GenLocated SrcSpanAnnN (IdGhcP p)
    forall (p :: Pass).
    (Anno (IdGhcP p) ~ SrcSpanAnnN) =>
    TyClDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
    tyClDeclLName

    -- | Does this declaration have a complete, user-supplied kind signature?
    -- See Note [CUSKs: complete user-supplied kind signatures]
    hsDeclHasCusk :: TyClDecl GhcRn -> Bool
    hsDeclHasCusk :: TyClDecl GhcRn -> Bool
    hsDeclHasCusk (FamDecl { tcdFam :: forall pass. TyClDecl pass -> FamilyDecl pass
    tcdFam =
        FamilyDecl { fdInfo :: forall pass. FamilyDecl pass -> FamilyInfo pass
    fdInfo      = FamilyInfo GhcRn
    fam_info
                   , fdTyVars :: forall pass. FamilyDecl pass -> LHsQTyVars pass
    fdTyVars    = LHsQTyVars GhcRn
    tyvars
                   , fdResultSig :: forall pass. FamilyDecl pass -> LFamilyResultSig pass
    fdResultSig = L EpAnnCO
    _ FamilyResultSig GhcRn
    resultSig } }) =
        case FamilyInfo GhcRn
    fam_info of
          ClosedTypeFamily {} -> LHsQTyVars GhcRn -> Bool
    forall (p :: Pass). LHsQTyVars (GhcPass p) -> Bool
    hsTvbAllKinded LHsQTyVars GhcRn
    tyvars
                              Bool -> Bool -> Bool
    && Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)) -> Bool
    forall a. Maybe a -> Bool
    isJust (FamilyResultSig GhcRn -> Maybe (LHsKind GhcRn)
    forall (p :: Pass).
    FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p))
    famResultKindSignature FamilyResultSig GhcRn
    resultSig)
          FamilyInfo GhcRn
    _ -> Bool
    True -- Un-associated open type/data families have CUSKs
    hsDeclHasCusk (SynDecl { tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars GhcRn
    tyvars, tcdRhs :: forall pass. TyClDecl pass -> LHsType pass
    tcdRhs = LHsKind GhcRn
    rhs })
      = LHsQTyVars GhcRn -> Bool
    forall (p :: Pass). LHsQTyVars (GhcPass p) -> Bool
    hsTvbAllKinded LHsQTyVars GhcRn
    tyvars Bool -> Bool -> Bool
    && Maybe (GenLocated SrcSpanAnnA (HsType GhcRn)) -> Bool
    forall a. Maybe a -> Bool
    isJust (LHsKind GhcRn -> Maybe (LHsKind GhcRn)
    forall (p :: Pass).
    LHsType (GhcPass p) -> Maybe (LHsType (GhcPass p))
    hsTyKindSig LHsKind GhcRn
    rhs)
    hsDeclHasCusk (DataDecl { tcdDExt :: forall pass. TyClDecl pass -> XDataDecl pass
    tcdDExt = DataDeclRn { tcdDataCusk :: DataDeclRn -> Bool
    tcdDataCusk = Bool
    cusk }}) = Bool
    cusk
    hsDeclHasCusk (ClassDecl { tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars GhcRn
    tyvars }) = LHsQTyVars GhcRn -> Bool
    forall (p :: Pass). LHsQTyVars (GhcPass p) -> Bool
    hsTvbAllKinded LHsQTyVars GhcRn
    tyvars

    -- Pretty-printing TyClDecl
    -- ~~~~~~~~~~~~~~~~~~~~~~~~

    instance (OutputableBndrId p) => Outputable (TyClDecl (GhcPass p)) where

        ppr :: TyClDecl (GhcPass p) -> SDoc
    ppr (FamDecl { tcdFam :: forall pass. TyClDecl pass -> FamilyDecl pass
    tcdFam = FamilyDecl (GhcPass p)
    decl }) = FamilyDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FamilyDecl (GhcPass p)
    decl
        ppr (SynDecl { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = LIdP (GhcPass p)
    ltycon, tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars (GhcPass p)
    tyvars, tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
    tcdFixity = LexicalFixity
    fixity
                     , tcdRhs :: forall pass. TyClDecl pass -> LHsType pass
    tcdRhs = LHsType (GhcPass p)
    rhs })
          = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                  LIdP (GhcPass p)
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    XRec (GhcPass p) (IdP (GhcPass p))
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pp_vanilla_decl_head LIdP (GhcPass p)
    ltycon LHsQTyVars (GhcPass p)
    tyvars LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    forall a. Maybe a
    Nothing SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    forall doc. IsLine doc => doc
    equals)
              Int
    4 (GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType (GhcPass p)
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    rhs)

        ppr (DataDecl { tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = LIdP (GhcPass p)
    ltycon, tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars (GhcPass p)
    tyvars, tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
    tcdFixity = LexicalFixity
    fixity
                      , tcdDataDefn :: forall pass. TyClDecl pass -> HsDataDefn pass
    tcdDataDefn = HsDataDefn (GhcPass p)
    defn })
          = (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    pp_data_defn (LIdP (GhcPass p)
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    XRec (GhcPass p) (IdP (GhcPass p))
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pp_vanilla_decl_head LIdP (GhcPass p)
    ltycon LHsQTyVars (GhcPass p)
    tyvars LexicalFixity
    fixity) HsDataDefn (GhcPass p)
    defn

        ppr (ClassDecl {tcdCtxt :: forall pass. TyClDecl pass -> Maybe (LHsContext pass)
    tcdCtxt = Maybe (LHsContext (GhcPass p))
    context, tcdLName :: forall pass. TyClDecl pass -> LIdP pass
    tcdLName = LIdP (GhcPass p)
    lclas, tcdTyVars :: forall pass. TyClDecl pass -> LHsQTyVars pass
    tcdTyVars = LHsQTyVars (GhcPass p)
    tyvars,
                        tcdFixity :: forall pass. TyClDecl pass -> LexicalFixity
    tcdFixity = LexicalFixity
    fixity,
                        tcdFDs :: forall pass. TyClDecl pass -> [LHsFunDep pass]
    tcdFDs  = [LHsFunDep (GhcPass p)]
    fds,
                        tcdSigs :: forall pass. TyClDecl pass -> [LSig pass]
    tcdSigs = [LSig (GhcPass p)]
    sigs, tcdMeths :: forall pass. TyClDecl pass -> LHsBinds pass
    tcdMeths = LHsBinds (GhcPass p)
    methods,
                        tcdATs :: forall pass. TyClDecl pass -> [LFamilyDecl pass]
    tcdATs = [LFamilyDecl (GhcPass p)]
    ats, tcdATDefs :: forall pass. TyClDecl pass -> [LTyFamDefltDecl pass]
    tcdATDefs = [LTyFamDefltDecl (GhcPass p)]
    at_defs})
          | [GenLocated SrcSpanAnnA (Sig (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LSig (GhcPass p)]
    [GenLocated SrcSpanAnnA (Sig (GhcPass p))]
    sigs Bool -> Bool -> Bool
    && [GenLocated SrcSpanAnnA (HsBindLR (GhcPass p) (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null LHsBinds (GhcPass p)
    [GenLocated SrcSpanAnnA (HsBindLR (GhcPass p) (GhcPass p))]
    methods Bool -> Bool -> Bool
    && [GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LFamilyDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))]
    ats Bool -> Bool -> Bool
    && [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LTyFamDefltDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))]
    at_defs -- No "where" part
          = SDoc
    top_matter

          | Bool
    otherwise       -- Laid out
          = [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ SDoc
    top_matter SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "where"
                 , Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [SDoc] -> SDoc
    pprDeclList ((GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (FamilyDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (FamilyDecl (GhcPass p) -> SDoc)
    -> (GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))
        -> FamilyDecl (GhcPass p))
    -> GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))
    -> FamilyDecl (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) [LFamilyDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (FamilyDecl (GhcPass p))]
    ats [SDoc] -> [SDoc] -> [SDoc]
    forall a. [a] -> [a] -> [a]
    ++
                                         (GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (TyFamInstDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TyFamDefltDecl (GhcPass p) -> SDoc
    pprTyFamDefltDecl (TyFamInstDecl (GhcPass p) -> SDoc)
    -> (GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))
        -> TyFamInstDecl (GhcPass p))
    -> GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))
    -> TyFamInstDecl (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) [LTyFamDefltDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))]
    at_defs [SDoc] -> [SDoc] -> [SDoc]
    forall a. [a] -> [a] -> [a]
    ++
                                         LHsBinds (GhcPass p) -> [LSig (GhcPass p)] -> [SDoc]
    forall (idL :: Pass) (idR :: Pass) (id2 :: Pass).
    (OutputableBndrId idL, OutputableBndrId idR,
     OutputableBndrId id2) =>
    LHsBindsLR (GhcPass idL) (GhcPass idR)
    -> [LSig (GhcPass id2)] -> [SDoc]
    pprLHsBindsForUser LHsBinds (GhcPass p)
    methods [LSig (GhcPass p)]
    sigs) ]
          where
            top_matter :: SDoc
    top_matter = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "class"
                        SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> LIdP (GhcPass p)
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    XRec (GhcPass p) (IdP (GhcPass p))
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pp_vanilla_decl_head LIdP (GhcPass p)
    lclas LHsQTyVars (GhcPass p)
    tyvars LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    context
                        SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [FunDep (GhcPass p)] -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    [FunDep (GhcPass p)] -> SDoc
    pprFundeps ((GenLocated SrcSpanAnnA (FunDep (GhcPass p)) -> FunDep (GhcPass p))
    -> [GenLocated SrcSpanAnnA (FunDep (GhcPass p))]
    -> [FunDep (GhcPass p)]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (FunDep (GhcPass p)) -> FunDep (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc [LHsFunDep (GhcPass p)]
    [GenLocated SrcSpanAnnA (FunDep (GhcPass p))]
    fds)

    instance OutputableBndrId p
           => Outputable (TyClGroup (GhcPass p)) where
      ppr :: TyClGroup (GhcPass p) -> SDoc
    ppr (TyClGroup { group_tyclds :: forall pass. TyClGroup pass -> [LTyClDecl pass]
    group_tyclds = [LTyClDecl (GhcPass p)]
    tyclds
                     , group_roles :: forall pass. TyClGroup pass -> [LRoleAnnotDecl pass]
    group_roles = [LRoleAnnotDecl (GhcPass p)]
    roles
                     , group_kisigs :: forall pass. TyClGroup pass -> [LStandaloneKindSig pass]
    group_kisigs = [LStandaloneKindSig (GhcPass p)]
    kisigs
                     , group_instds :: forall pass. TyClGroup pass -> [LInstDecl pass]
    group_instds = [LInstDecl (GhcPass p)]
    instds
                     }
          )
        = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "TyClGroup") Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
          [GenLocated SrcSpanAnnA (StandaloneKindSig (GhcPass p))] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LStandaloneKindSig (GhcPass p)]
    [GenLocated SrcSpanAnnA (StandaloneKindSig (GhcPass p))]
    kisigs SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$
          [GenLocated SrcSpanAnnA (TyClDecl (GhcPass p))] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LTyClDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (TyClDecl (GhcPass p))]
    tyclds SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$
          [GenLocated SrcSpanAnnA (RoleAnnotDecl (GhcPass p))] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LRoleAnnotDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (RoleAnnotDecl (GhcPass p))]
    roles SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$
          [GenLocated SrcSpanAnnA (InstDecl (GhcPass p))] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (InstDecl (GhcPass p))]
    instds

    pp_vanilla_decl_head :: (OutputableBndrId p)
       => XRec (GhcPass p) (IdP (GhcPass p))
       -> LHsQTyVars (GhcPass p)
       -> LexicalFixity
       -> Maybe (LHsContext (GhcPass p))
       -> SDoc
    pp_vanilla_decl_head :: forall (p :: Pass).
    OutputableBndrId p =>
    XRec (GhcPass p) (IdP (GhcPass p))
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pp_vanilla_decl_head XRec (GhcPass p) (IdP (GhcPass p))
    thing (HsQTvs { hsq_explicit :: forall pass.
    LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass]
    hsq_explicit = [LHsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)]
    tyvars }) LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    context
     = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [Maybe (LHsContext (GhcPass p)) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LHsContext (GhcPass p)) -> SDoc
    pprLHsContext Maybe (LHsContext (GhcPass p))
    context, [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    -> SDoc
    pp_tyvars [LHsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)]
    [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    tyvars]
      where
        pp_tyvars :: [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    -> SDoc
    pp_tyvars (GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    varl:[GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    varsr)
          | LexicalFixity
    fixity LexicalFixity -> LexicalFixity -> Bool
    forall a. Eq a => a -> a -> Bool
    == LexicalFixity
    Infix, GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    varr:varsr' :: [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    varsr'@(GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    _:[GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    _) <- [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    varsr
             -- If varsr has at least 2 elements, parenthesize.
             = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '(',HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    varl), IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprInfixOcc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    thing)
                    , (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr(HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc)
    -> (GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
        -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> GenLocated
         SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    varr, Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    ')'
                    , [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep ((GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
     -> SDoc)
    -> [GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr(HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc)
    -> (GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
        -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> GenLocated
         SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    varsr')]
          | LexicalFixity
    fixity LexicalFixity -> LexicalFixity -> Bool
    forall a. Eq a => a -> a -> Bool
    == LexicalFixity
    Infix
             = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    varl), IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprInfixOcc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    thing)
             , [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep ((GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
     -> SDoc)
    -> [GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr(HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc)
    -> (GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
        -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> GenLocated
         SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) [GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    varsr)]
          | Bool
    otherwise = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [ IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    thing)
                      , [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep ((GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
     -> SDoc)
    -> [GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr(HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p) -> SDoc)
    -> (GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
        -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> GenLocated
         SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) (GenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    varlGenLocated
      SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))
    -> [GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    -> [GenLocated
          SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    forall a. a -> [a] -> [a]
    :[GenLocated
       SrcSpanAnnA (HsTyVarBndr (HsBndrVis (GhcPass p)) (GhcPass p))]
    varsr))]
        pp_tyvars [] = IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (IdP (GhcPass p))
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    thing)

    pprTyClDeclFlavour :: TyClDecl (GhcPass p) -> SDoc
    pprTyClDeclFlavour :: forall (p :: Pass). TyClDecl (GhcPass p) -> SDoc
    pprTyClDeclFlavour (ClassDecl {})   = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "class"
    pprTyClDeclFlavour (SynDecl {})     = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type"
    pprTyClDeclFlavour (FamDecl { tcdFam :: forall pass. TyClDecl pass -> FamilyDecl pass
    tcdFam = FamilyDecl { fdInfo :: forall pass. FamilyDecl pass -> FamilyInfo pass
    fdInfo = FamilyInfo (GhcPass p)
    info }})
      = FamilyInfo (GhcPass p) -> SDoc
    forall pass. FamilyInfo pass -> SDoc
    pprFlavour FamilyInfo (GhcPass p)
    info SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "family"
    pprTyClDeclFlavour (DataDecl { tcdDataDefn :: forall pass. TyClDecl pass -> HsDataDefn pass
    tcdDataDefn = HsDataDefn { dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataDefnCons (LConDecl (GhcPass p))
    nd } })
      = NewOrData -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    -> NewOrData
    forall a. DataDefnCons a -> NewOrData
    dataDefnConsNewOrData DataDefnCons (LConDecl (GhcPass p))
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    nd)

    instance OutputableBndrId p => Outputable (FunDep (GhcPass p)) where
      ppr :: FunDep (GhcPass p) -> SDoc
    ppr = FunDep (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    FunDep (GhcPass p) -> SDoc
    pprFunDep

    type instance XCFunDep    (GhcPass _) = TokRarrow
    type instance XXFunDep    (GhcPass _) = DataConCantHappen

    pprFundeps :: OutputableBndrId p => [FunDep (GhcPass p)] -> SDoc
    pprFundeps :: forall (p :: Pass).
    OutputableBndrId p =>
    [FunDep (GhcPass p)] -> SDoc
    pprFundeps []  = SDoc
    forall doc. IsOutput doc => doc
    empty
    pprFundeps [FunDep (GhcPass p)]
    fds = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep (SDoc
    forall doc. IsLine doc => doc
    vbar SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : SDoc -> [SDoc] -> [SDoc]
    forall doc. IsLine doc => doc -> [doc] -> [doc]
    punctuate SDoc
    forall doc. IsLine doc => doc
    comma ((FunDep (GhcPass p) -> SDoc) -> [FunDep (GhcPass p)] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map FunDep (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    FunDep (GhcPass p) -> SDoc
    pprFunDep [FunDep (GhcPass p)]
    fds))

    pprFunDep :: OutputableBndrId p => FunDep (GhcPass p) -> SDoc
    pprFunDep :: forall (p :: Pass).
    OutputableBndrId p =>
    FunDep (GhcPass p) -> SDoc
    pprFunDep (FunDep XCFunDep (GhcPass p)
    _ [LIdP (GhcPass p)]
    us [LIdP (GhcPass p)]
    vs) = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [[GenLocated (Anno (IdGhcP p)) (IdGhcP p)] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    interppSP [LIdP (GhcPass p)]
    [GenLocated (Anno (IdGhcP p)) (IdGhcP p)]
    us, SDoc
    arrow, [GenLocated (Anno (IdGhcP p)) (IdGhcP p)] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    interppSP [LIdP (GhcPass p)]
    [GenLocated (Anno (IdGhcP p)) (IdGhcP p)]
    vs]

    {- *********************************************************************
    *                                                                      *
                             TyClGroup
            Strongly connected components of
          type, class, instance, and role declarations
    *                                                                      *
    ********************************************************************* -}

    type instance XCTyClGroup (GhcPass _) = NoExtField
    type instance XXTyClGroup (GhcPass _) = DataConCantHappen

    {- *********************************************************************
    *                                                                      *
                   Data and type family declarations
    *                                                                      *
    ********************************************************************* -}

    type instance XNoSig            (GhcPass _) = NoExtField
    type instance XCKindSig         (GhcPass _) = NoExtField

    type instance XTyVarSig         (GhcPass _) = NoExtField
    type instance XXFamilyResultSig (GhcPass _) = DataConCantHappen

    type instance XCFamilyDecl    (GhcPass _) = AnnFamilyDecl
    type instance XXFamilyDecl    (GhcPass _) = DataConCantHappen

    data AnnFamilyDecl
      = AnnFamilyDecl {
          AnnFamilyDecl -> [EpToken "("]
    afd_openp  :: [EpToken "("],
          AnnFamilyDecl -> [EpToken ")"]
    afd_closep :: [EpToken ")"],
          AnnFamilyDecl -> EpToken "type"
    afd_type   :: EpToken "type",
          AnnFamilyDecl -> EpToken "data"
    afd_data   :: EpToken "data",
          AnnFamilyDecl -> EpToken "family"
    afd_family :: EpToken "family",
          AnnFamilyDecl -> TokDcolon
    afd_dcolon :: TokDcolon,
          AnnFamilyDecl -> EpToken "="
    afd_equal  :: EpToken "=",
          AnnFamilyDecl -> EpToken "|"
    afd_vbar   :: EpToken "|",
          AnnFamilyDecl -> EpToken "where"
    afd_where  :: EpToken "where",
          AnnFamilyDecl -> EpToken "{"
    afd_openc  :: EpToken "{",
          AnnFamilyDecl -> EpToken ".."
    afd_dotdot :: EpToken "..",
          AnnFamilyDecl -> EpToken "}"
    afd_closec :: EpToken "}"
      } deriving Typeable AnnFamilyDecl
    Typeable AnnFamilyDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnFamilyDecl -> c AnnFamilyDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnFamilyDecl)
    -> (AnnFamilyDecl -> Constr)
    -> (AnnFamilyDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnFamilyDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnFamilyDecl))
    -> ((forall b. Data b => b -> b) -> AnnFamilyDecl -> AnnFamilyDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnFamilyDecl -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnFamilyDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl)
    -> Data AnnFamilyDecl
    AnnFamilyDecl -> Constr
    AnnFamilyDecl -> DataType
    (forall b. Data b => b -> b) -> AnnFamilyDecl -> AnnFamilyDecl
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> AnnFamilyDecl -> u
    forall u. (forall d. Data d => d -> u) -> AnnFamilyDecl -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnFamilyDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnFamilyDecl -> c AnnFamilyDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnFamilyDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnFamilyDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnFamilyDecl -> c AnnFamilyDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnFamilyDecl -> c AnnFamilyDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnFamilyDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnFamilyDecl
    $ctoConstr :: AnnFamilyDecl -> Constr
    toConstr :: AnnFamilyDecl -> Constr
    $cdataTypeOf :: AnnFamilyDecl -> DataType
    dataTypeOf :: AnnFamilyDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnFamilyDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnFamilyDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnFamilyDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnFamilyDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnFamilyDecl -> AnnFamilyDecl
    gmapT :: (forall b. Data b => b -> b) -> AnnFamilyDecl -> AnnFamilyDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnFamilyDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnFamilyDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnFamilyDecl -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnFamilyDecl -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnFamilyDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnFamilyDecl -> m AnnFamilyDecl
    Data

    instance NoAnn AnnFamilyDecl where
      noAnn :: AnnFamilyDecl
    noAnn = [EpToken "("]
    -> [EpToken ")"]
    -> EpToken "type"
    -> EpToken "data"
    -> EpToken "family"
    -> TokDcolon
    -> EpToken "="
    -> EpToken "|"
    -> EpToken "where"
    -> EpToken "{"
    -> EpToken ".."
    -> EpToken "}"
    -> AnnFamilyDecl
    AnnFamilyDecl [EpToken "("]
    forall a. NoAnn a => a
    noAnn [EpToken ")"]
    forall a. NoAnn a => a
    noAnn EpToken "type"
    forall a. NoAnn a => a
    noAnn EpToken "data"
    forall a. NoAnn a => a
    noAnn EpToken "family"
    forall a. NoAnn a => a
    noAnn TokDcolon
    forall a. NoAnn a => a
    noAnn EpToken "="
    forall a. NoAnn a => a
    noAnn EpToken "|"
    forall a. NoAnn a => a
    noAnn EpToken "where"
    forall a. NoAnn a => a
    noAnn EpToken "{"
    forall a. NoAnn a => a
    noAnn EpToken ".."
    forall a. NoAnn a => a
    noAnn EpToken "}"
    forall a. NoAnn a => a
    noAnn

    ------------- Functions over FamilyDecls -----------

    familyDeclLName :: FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
    familyDeclLName :: forall (p :: Pass).
    FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
    familyDeclLName (FamilyDecl { fdLName :: forall pass. FamilyDecl pass -> LIdP pass
    fdLName = LIdP (GhcPass p)
    n }) = LIdP (GhcPass p)
    n

    familyDeclName :: FamilyDecl (GhcPass p) -> IdP (GhcPass p)
    familyDeclName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> IdP (GhcPass p)
    familyDeclName = GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p)
    -> (FamilyDecl (GhcPass p)
        -> GenLocated (Anno (IdGhcP p)) (IdGhcP p))
    -> FamilyDecl (GhcPass p)
    -> IdGhcP p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
    FamilyDecl (GhcPass p) -> GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    forall (p :: Pass).
    FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
    familyDeclLName

    famResultKindSignature :: FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p))
    famResultKindSignature :: forall (p :: Pass).
    FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p))
    famResultKindSignature (NoSig XNoSig (GhcPass p)
    _) = Maybe (XRec (GhcPass p) (HsType (GhcPass p)))
    Maybe (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    forall a. Maybe a
    Nothing
    famResultKindSignature (KindSig XCKindSig (GhcPass p)
    _ XRec (GhcPass p) (HsType (GhcPass p))
    ki) = GenLocated SrcSpanAnnA (HsType (GhcPass p))
    -> Maybe (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    forall a. a -> Maybe a
    Just XRec (GhcPass p) (HsType (GhcPass p))
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    ki
    famResultKindSignature (TyVarSig XTyVarSig (GhcPass p)
    _ LHsTyVarBndr () (GhcPass p)
    bndr) =
      case HsTyVarBndr () (GhcPass p) -> HsBndrKind (GhcPass p)
    forall flag (pass :: Pass).
    HsTyVarBndr flag (GhcPass pass) -> HsBndrKind (GhcPass pass)
    hsBndrKind (GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass p))
    -> HsTyVarBndr () (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc LHsTyVarBndr () (GhcPass p)
    GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass p))
    bndr) of
        HsBndrNoKind XBndrNoKind (GhcPass p)
    _  -> Maybe (XRec (GhcPass p) (HsType (GhcPass p)))
    Maybe (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    forall a. Maybe a
    Nothing
        HsBndrKind XBndrKind (GhcPass p)
    _ XRec (GhcPass p) (HsType (GhcPass p))
    ki -> GenLocated SrcSpanAnnA (HsType (GhcPass p))
    -> Maybe (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    forall a. a -> Maybe a
    Just XRec (GhcPass p) (HsType (GhcPass p))
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    ki

    -- | Maybe return name of the result type variable
    resultVariableName :: FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a))
    resultVariableName :: forall (a :: Pass).
    FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a))
    resultVariableName (TyVarSig XTyVarSig (GhcPass a)
    _ LHsTyVarBndr () (GhcPass a)
    sig) = LHsTyVarBndr () (GhcPass a) -> Maybe (IdP (GhcPass a))
    forall flag (p :: Pass).
    LHsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p))
    hsLTyVarName LHsTyVarBndr () (GhcPass a)
    sig
    resultVariableName FamilyResultSig (GhcPass a)
    _                = Maybe (IdP (GhcPass a))
    Maybe (IdGhcP a)
    forall a. Maybe a
    Nothing

    ------------- Pretty printing FamilyDecls -----------

    type instance XCInjectivityAnn  (GhcPass _) = TokRarrow
    type instance XXInjectivityAnn  (GhcPass _) = DataConCantHappen

    instance OutputableBndrId p
           => Outputable (FamilyDecl (GhcPass p)) where
      ppr :: FamilyDecl (GhcPass p) -> SDoc
    ppr (FamilyDecl { fdInfo :: forall pass. FamilyDecl pass -> FamilyInfo pass
    fdInfo = FamilyInfo (GhcPass p)
    info, fdLName :: forall pass. FamilyDecl pass -> LIdP pass
    fdLName = LIdP (GhcPass p)
    ltycon
                      , fdTopLevel :: forall pass. FamilyDecl pass -> TopLevelFlag
    fdTopLevel = TopLevelFlag
    top_level
                      , fdTyVars :: forall pass. FamilyDecl pass -> LHsQTyVars pass
    fdTyVars = LHsQTyVars (GhcPass p)
    tyvars
                      , fdFixity :: forall pass. FamilyDecl pass -> LexicalFixity
    fdFixity = LexicalFixity
    fixity
                      , fdResultSig :: forall pass. FamilyDecl pass -> LFamilyResultSig pass
    fdResultSig = L EpAnnCO
    _ FamilyResultSig (GhcPass p)
    result
                      , fdInjectivityAnn :: forall pass. FamilyDecl pass -> Maybe (LInjectivityAnn pass)
    fdInjectivityAnn = Maybe (LInjectivityAnn (GhcPass p))
    mb_inj })
        = [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ FamilyInfo (GhcPass p) -> SDoc
    forall pass. FamilyInfo pass -> SDoc
    pprFlavour FamilyInfo (GhcPass p)
    info SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_top_level SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                 LIdP (GhcPass p)
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    XRec (GhcPass p) (IdP (GhcPass p))
    -> LHsQTyVars (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pp_vanilla_decl_head LIdP (GhcPass p)
    ltycon LHsQTyVars (GhcPass p)
    tyvars LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    forall a. Maybe a
    Nothing SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
                 SDoc
    pp_kind SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_inj SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_where
               , Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ SDoc
    pp_eqns ]
        where
          pp_top_level :: SDoc
    pp_top_level = case TopLevelFlag
    top_level of
                           TopLevelFlag
    TopLevel    -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "family"
                           TopLevelFlag
    NotTopLevel -> SDoc
    forall doc. IsOutput doc => doc
    empty

          pp_kind :: SDoc
    pp_kind = case FamilyResultSig (GhcPass p)
    result of
                      NoSig    XNoSig (GhcPass p)
    _         -> SDoc
    forall doc. IsOutput doc => doc
    empty
                      KindSig  XCKindSig (GhcPass p)
    _ LHsKind (GhcPass p)
    kind    -> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsKind (GhcPass p)
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    kind
                      TyVarSig XTyVarSig (GhcPass p)
    _ LHsTyVarBndr () (GhcPass p)
    tv_bndr -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "=" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsTyVarBndr () (GhcPass p)
    GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass p))
    tv_bndr
          pp_inj :: SDoc
    pp_inj = case Maybe (LInjectivityAnn (GhcPass p))
    mb_inj of
                     Just (L EpAnnCO
    _ (InjectivityAnn XCInjectivityAnn (GhcPass p)
    _ LIdP (GhcPass p)
    lhs [LIdP (GhcPass p)]
    rhs)) ->
                       [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [ SDoc
    forall doc. IsLine doc => doc
    vbar, GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    lhs, String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "->", [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep ((GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc)
    -> [GenLocated (Anno (IdGhcP p)) (IdGhcP p)] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LIdP (GhcPass p)]
    [GenLocated (Anno (IdGhcP p)) (IdGhcP p)]
    rhs) ]
                     Maybe (LInjectivityAnn (GhcPass p))
    Nothing -> SDoc
    forall doc. IsOutput doc => doc
    empty
          (SDoc
    pp_where, SDoc
    pp_eqns) = case FamilyInfo (GhcPass p)
    info of
            ClosedTypeFamily Maybe [LTyFamInstEqn (GhcPass p)]
    mb_eqns ->
              ( String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "where"
              , case Maybe [LTyFamInstEqn (GhcPass p)]
    mb_eqns of
                  Maybe [LTyFamInstEqn (GhcPass p)]
    Nothing   -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    ".."
                  Just [LTyFamInstEqn (GhcPass p)]
    eqns -> [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
    forall a b. (a -> b) -> a -> b
    $ (GenLocated
       SrcSpanAnnA
       (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
     -> SDoc)
    -> [GenLocated
          SrcSpanAnnA
          (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))]
    -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (TyFamInstEqn (GhcPass p) -> SDoc
    FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TyFamInstEqn (GhcPass p) -> SDoc
    ppr_fam_inst_eqn (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
     -> SDoc)
    -> (GenLocated
          SrcSpanAnnA
          (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
        -> FamEqn
             (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
    -> GenLocated
         SrcSpanAnnA
         (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated
      SrcSpanAnnA
      (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
    -> FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    forall l e. GenLocated l e -> e
    unLoc) [LTyFamInstEqn (GhcPass p)]
    [GenLocated
       SrcSpanAnnA
       (FamEqn (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))]
    eqns )
            FamilyInfo (GhcPass p)
    _ -> (SDoc
    forall doc. IsOutput doc => doc
    empty, SDoc
    forall doc. IsOutput doc => doc
    empty)

    {- *********************************************************************
    *                                                                      *
                   Data types and data constructors
    *                                                                      *
    ********************************************************************* -}

    type instance XCHsDataDefn    (GhcPass _) = AnnDataDefn
    type instance XXHsDataDefn    (GhcPass _) = DataConCantHappen

    type instance XCHsDerivingClause    (GhcPass _) = EpToken "deriving"
    type instance XXHsDerivingClause    (GhcPass _) = DataConCantHappen

    instance OutputableBndrId p
           => Outputable (HsDerivingClause (GhcPass p)) where
      ppr :: HsDerivingClause (GhcPass p) -> SDoc
    ppr (HsDerivingClause { deriv_clause_strategy :: forall pass. HsDerivingClause pass -> Maybe (LDerivStrategy pass)
    deriv_clause_strategy = Maybe (LDerivStrategy (GhcPass p))
    dcs
                            , deriv_clause_tys :: forall pass. HsDerivingClause pass -> LDerivClauseTys pass
    deriv_clause_tys      = L SrcSpanAnnC
    _ DerivClauseTys (GhcPass p)
    dct })
        = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "deriving"
               , SDoc
    pp_strat_before
               , DerivClauseTys (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DerivClauseTys (GhcPass p)
    dct
               , SDoc
    pp_strat_after ]
          where
            -- @via@ is unique in that in comes /after/ the class being derived,
            -- so we must special-case it.
            (SDoc
    pp_strat_before, SDoc
    pp_strat_after) =
              case Maybe (LDerivStrategy (GhcPass p))
    dcs of
                Just (L EpAnnCO
    _ via :: DerivStrategy (GhcPass p)
    via@ViaStrategy{}) -> (SDoc
    forall doc. IsOutput doc => doc
    empty, DerivStrategy (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DerivStrategy (GhcPass p)
    via)
                Maybe (LDerivStrategy (GhcPass p))
    _                            -> (Maybe (LDerivStrategy (GhcPass p)) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LDerivStrategy (GhcPass p)) -> SDoc
    ppDerivStrategy Maybe (LDerivStrategy (GhcPass p))
    dcs, SDoc
    forall doc. IsOutput doc => doc
    empty)

    -- | A short description of a @DerivStrategy'@.
    derivStrategyName :: DerivStrategy a -> SDoc
    derivStrategyName :: forall a. DerivStrategy a -> SDoc
    derivStrategyName = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (String -> SDoc)
    -> (DerivStrategy a -> String) -> DerivStrategy a -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . DerivStrategy a -> String
    forall {pass}. DerivStrategy pass -> String
    go
      where
        go :: DerivStrategy pass -> String
    go StockStrategy    {} = String
    "stock"
        go AnyclassStrategy {} = String
    "anyclass"
        go NewtypeStrategy  {} = String
    "newtype"
        go ViaStrategy      {} = String
    "via"

    type instance XDctSingle (GhcPass _) = NoExtField
    type instance XDctMulti  (GhcPass _) = NoExtField
    type instance XXDerivClauseTys (GhcPass _) = DataConCantHappen

    instance OutputableBndrId p => Outputable (DerivClauseTys (GhcPass p)) where
      ppr :: DerivClauseTys (GhcPass p) -> SDoc
    ppr (DctSingle XDctSingle (GhcPass p)
    _ LHsSigType (GhcPass p)
    ty) = GenLocated SrcSpanAnnA (HsSigType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType (GhcPass p)
    GenLocated SrcSpanAnnA (HsSigType (GhcPass p))
    ty
      ppr (DctMulti XDctMulti (GhcPass p)
    _ [LHsSigType (GhcPass p)]
    tys) = SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens ([GenLocated SrcSpanAnnA (HsSigType (GhcPass p))] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    interpp'SP [LHsSigType (GhcPass p)]
    [GenLocated SrcSpanAnnA (HsSigType (GhcPass p))]
    tys)

    type instance XStandaloneKindSig GhcPs = (EpToken "type", TokDcolon)
    type instance XStandaloneKindSig GhcRn = NoExtField
    type instance XStandaloneKindSig GhcTc = NoExtField

    type instance XXStandaloneKindSig (GhcPass p) = DataConCantHappen

    standaloneKindSigName :: StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
    standaloneKindSigName :: forall (p :: Pass).
    StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
    standaloneKindSigName (StandaloneKindSig XStandaloneKindSig (GhcPass p)
    _ LIdP (GhcPass p)
    lname LHsSigType (GhcPass p)
    _) = GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    lname

    type instance XConDeclGADT GhcPs = AnnConDeclGADT
    type instance XConDeclGADT GhcRn = NoExtField
    type instance XConDeclGADT GhcTc = NoExtField

    type instance XConDeclH98  GhcPs = AnnConDeclH98
    type instance XConDeclH98  GhcRn = NoExtField
    type instance XConDeclH98  GhcTc = NoExtField

    type instance XXConDecl (GhcPass _) = DataConCantHappen

    type instance XPrefixConGADT       (GhcPass _) = NoExtField

    type instance XRecConGADT          GhcPs = TokRarrow
    type instance XRecConGADT          GhcRn = NoExtField
    type instance XRecConGADT          GhcTc = NoExtField

    type instance XXConDeclGADTDetails (GhcPass _) = DataConCantHappen

    data AnnConDeclH98
      = AnnConDeclH98 {
        AnnConDeclH98 -> TokForall
    acdh_forall  :: TokForall,
        AnnConDeclH98 -> EpToken "."
    acdh_dot :: EpToken ".",
        AnnConDeclH98 -> TokDarrow
    acdh_darrow :: TokDarrow
      } deriving Typeable AnnConDeclH98
    Typeable AnnConDeclH98 =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnConDeclH98 -> c AnnConDeclH98)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnConDeclH98)
    -> (AnnConDeclH98 -> Constr)
    -> (AnnConDeclH98 -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclH98))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnConDeclH98))
    -> ((forall b. Data b => b -> b) -> AnnConDeclH98 -> AnnConDeclH98)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnConDeclH98 -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnConDeclH98 -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98)
    -> Data AnnConDeclH98
    AnnConDeclH98 -> Constr
    AnnConDeclH98 -> DataType
    (forall b. Data b => b -> b) -> AnnConDeclH98 -> AnnConDeclH98
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> AnnConDeclH98 -> u
    forall u. (forall d. Data d => d -> u) -> AnnConDeclH98 -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnConDeclH98
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnConDeclH98 -> c AnnConDeclH98
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclH98)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnConDeclH98)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnConDeclH98 -> c AnnConDeclH98
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnConDeclH98 -> c AnnConDeclH98
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnConDeclH98
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnConDeclH98
    $ctoConstr :: AnnConDeclH98 -> Constr
    toConstr :: AnnConDeclH98 -> Constr
    $cdataTypeOf :: AnnConDeclH98 -> DataType
    dataTypeOf :: AnnConDeclH98 -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclH98)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclH98)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnConDeclH98)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnConDeclH98)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnConDeclH98 -> AnnConDeclH98
    gmapT :: (forall b. Data b => b -> b) -> AnnConDeclH98 -> AnnConDeclH98
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclH98 -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnConDeclH98 -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnConDeclH98 -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnConDeclH98 -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnConDeclH98 -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnConDeclH98 -> m AnnConDeclH98
    Data

    instance NoAnn AnnConDeclH98 where
      noAnn :: AnnConDeclH98
    noAnn = TokForall -> EpToken "." -> TokDarrow -> AnnConDeclH98
    AnnConDeclH98 TokForall
    forall a. NoAnn a => a
    noAnn EpToken "."
    forall a. NoAnn a => a
    noAnn TokDarrow
    forall a. NoAnn a => a
    noAnn

    data AnnConDeclGADT
      = AnnConDeclGADT {
        AnnConDeclGADT -> [EpToken "("]
    acdg_openp  :: [EpToken "("],
        AnnConDeclGADT -> [EpToken ")"]
    acdg_closep :: [EpToken ")"],
        AnnConDeclGADT -> TokDcolon
    acdg_dcolon :: TokDcolon
      } deriving Typeable AnnConDeclGADT
    Typeable AnnConDeclGADT =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnConDeclGADT -> c AnnConDeclGADT)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnConDeclGADT)
    -> (AnnConDeclGADT -> Constr)
    -> (AnnConDeclGADT -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclGADT))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnConDeclGADT))
    -> ((forall b. Data b => b -> b)
        -> AnnConDeclGADT -> AnnConDeclGADT)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> AnnConDeclGADT -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnConDeclGADT -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> AnnConDeclGADT -> m AnnConDeclGADT)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnConDeclGADT -> m AnnConDeclGADT)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnConDeclGADT -> m AnnConDeclGADT)
    -> Data AnnConDeclGADT
    AnnConDeclGADT -> Constr
    AnnConDeclGADT -> DataType
    (forall b. Data b => b -> b) -> AnnConDeclGADT -> AnnConDeclGADT
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> AnnConDeclGADT -> u
    forall u. (forall d. Data d => d -> u) -> AnnConDeclGADT -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnConDeclGADT
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnConDeclGADT -> c AnnConDeclGADT
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclGADT)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnConDeclGADT)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnConDeclGADT -> c AnnConDeclGADT
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnConDeclGADT -> c AnnConDeclGADT
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnConDeclGADT
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnConDeclGADT
    $ctoConstr :: AnnConDeclGADT -> Constr
    toConstr :: AnnConDeclGADT -> Constr
    $cdataTypeOf :: AnnConDeclGADT -> DataType
    dataTypeOf :: AnnConDeclGADT -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclGADT)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnConDeclGADT)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnConDeclGADT)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnConDeclGADT)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnConDeclGADT -> AnnConDeclGADT
    gmapT :: (forall b. Data b => b -> b) -> AnnConDeclGADT -> AnnConDeclGADT
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnConDeclGADT -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnConDeclGADT -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnConDeclGADT -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnConDeclGADT -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnConDeclGADT -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnConDeclGADT -> m AnnConDeclGADT
    Data

    instance NoAnn AnnConDeclGADT where
      noAnn :: AnnConDeclGADT
    noAnn = [EpToken "("] -> [EpToken ")"] -> TokDcolon -> AnnConDeclGADT
    AnnConDeclGADT [EpToken "("]
    forall a. NoAnn a => a
    noAnn [EpToken ")"]
    forall a. NoAnn a => a
    noAnn TokDcolon
    forall a. NoAnn a => a
    noAnn

    -- Codomain could be 'NonEmpty', but at the moment all users need a list.
    getConNames :: ConDecl GhcRn -> [LocatedN Name]
    getConNames :: ConDecl GhcRn -> [LocatedN SplicePointName]
    getConNames ConDeclH98  {con_name :: forall pass. ConDecl pass -> LIdP pass
    con_name  = LIdP GhcRn
    name}  = [LIdP GhcRn
    LocatedN SplicePointName
    name]
    getConNames ConDeclGADT {con_names :: forall pass. ConDecl pass -> NonEmpty (LIdP pass)
    con_names = NonEmpty (LIdP GhcRn)
    names} = NonEmpty (LocatedN SplicePointName) -> [LocatedN SplicePointName]
    forall a. NonEmpty a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList NonEmpty (LIdP GhcRn)
    NonEmpty (LocatedN SplicePointName)
    names

    -- | Return @'Just' fields@ if a data constructor declaration uses record
    -- syntax (i.e., 'RecCon'), where @fields@ are the field selectors.
    -- Otherwise, return 'Nothing'.
    getRecConArgs_maybe :: ConDecl GhcRn -> Maybe (LocatedL [LConDeclField GhcRn])
    getRecConArgs_maybe :: ConDecl GhcRn -> Maybe (LocatedL [LConDeclField GhcRn])
    getRecConArgs_maybe (ConDeclH98{con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
    con_args = HsConDeclH98Details GhcRn
    args}) = case HsConDeclH98Details GhcRn
    args of
      PrefixCon{} -> Maybe (LocatedL [LConDeclField GhcRn])
    Maybe (LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)])
    forall a. Maybe a
    Nothing
      RecCon XRec GhcRn [LConDeclField GhcRn]
    flds -> LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)]
    -> Maybe (LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)])
    forall a. a -> Maybe a
    Just XRec GhcRn [LConDeclField GhcRn]
    LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)]
    flds
      InfixCon{}  -> Maybe (LocatedL [LConDeclField GhcRn])
    Maybe (LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)])
    forall a. Maybe a
    Nothing
    getRecConArgs_maybe (ConDeclGADT{con_g_args :: forall pass. ConDecl pass -> HsConDeclGADTDetails pass
    con_g_args = HsConDeclGADTDetails GhcRn
    args}) = case HsConDeclGADTDetails GhcRn
    args of
      PrefixConGADT{} -> Maybe (LocatedL [LConDeclField GhcRn])
    Maybe (LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)])
    forall a. Maybe a
    Nothing
      RecConGADT XRecConGADT GhcRn
    _ XRec GhcRn [LConDeclField GhcRn]
    flds -> LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)]
    -> Maybe (LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)])
    forall a. a -> Maybe a
    Just XRec GhcRn [LConDeclField GhcRn]
    LocatedL [GenLocated SrcSpanAnnA (ConDeclField GhcRn)]
    flds

    hsConDeclTheta :: Maybe (LHsContext (GhcPass p)) -> [LHsType (GhcPass p)]
    hsConDeclTheta :: forall (p :: Pass).
    Maybe (LHsContext (GhcPass p)) -> [LHsType (GhcPass p)]
    hsConDeclTheta Maybe (LHsContext (GhcPass p))
    Nothing            = []
    hsConDeclTheta (Just (L SrcSpanAnnC
    _ [GenLocated SrcSpanAnnA (HsType (GhcPass p))]
    theta)) = [XRec (GhcPass p) (HsType (GhcPass p))]
    [GenLocated SrcSpanAnnA (HsType (GhcPass p))]
    theta

    ppDataDefnHeader
     :: (OutputableBndrId p)
     => (Maybe (LHsContext (GhcPass p)) -> SDoc)   -- Printing the header
     -> HsDataDefn (GhcPass p)
     -> SDoc
    ppDataDefnHeader :: forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    ppDataDefnHeader Maybe (LHsContext (GhcPass p)) -> SDoc
    pp_hdr HsDataDefn
      { dd_ctxt :: forall pass. HsDataDefn pass -> Maybe (LHsContext pass)
    dd_ctxt = Maybe (LHsContext (GhcPass p))
    context
      , dd_cType :: forall pass. HsDataDefn pass -> Maybe (XRec pass CType)
    dd_cType = Maybe (XRec (GhcPass p) CType)
    mb_ct
      , dd_kindSig :: forall pass. HsDataDefn pass -> Maybe (LHsKind pass)
    dd_kindSig = Maybe (LHsKind (GhcPass p))
    mb_sig
      , dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataDefnCons (LConDecl (GhcPass p))
    condecls }
      = SDoc
    pp_type SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> NewOrData -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    -> NewOrData
    forall a. DataDefnCons a -> NewOrData
    dataDefnConsNewOrData DataDefnCons (LConDecl (GhcPass p))
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    condecls) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_ct SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe (LHsContext (GhcPass p)) -> SDoc
    pp_hdr Maybe (LHsContext (GhcPass p))
    context SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_sig
      where
        pp_type :: SDoc
    pp_type
          | DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p))) -> Bool
    forall a. DataDefnCons a -> Bool
    isTypeDataDefnCons DataDefnCons (LConDecl (GhcPass p))
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    condecls = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type"
          | Bool
    otherwise = SDoc
    forall doc. IsOutput doc => doc
    empty
        pp_ct :: SDoc
    pp_ct = case Maybe (XRec (GhcPass p) CType)
    mb_ct of
                   Maybe (XRec (GhcPass p) CType)
    Nothing -> SDoc
    forall doc. IsOutput doc => doc
    empty
                   Just XRec (GhcPass p) CType
    ct -> GenLocated SrcSpanAnnP CType -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr XRec (GhcPass p) CType
    GenLocated SrcSpanAnnP CType
    ct
        pp_sig :: SDoc
    pp_sig = case Maybe (LHsKind (GhcPass p))
    mb_sig of
                   Maybe (LHsKind (GhcPass p))
    Nothing   -> SDoc
    forall doc. IsOutput doc => doc
    empty
                   Just LHsKind (GhcPass p)
    kind -> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsKind (GhcPass p)
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    kind

    pp_data_defn :: (OutputableBndrId p)
                      => (Maybe (LHsContext (GhcPass p)) -> SDoc)   -- Printing the header
                      -> HsDataDefn (GhcPass p)
                      -> SDoc
    pp_data_defn :: forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    pp_data_defn Maybe (LHsContext (GhcPass p)) -> SDoc
    pp_hdr defn :: HsDataDefn (GhcPass p)
    defn@HsDataDefn
      { dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataDefnCons (LConDecl (GhcPass p))
    condecls
      , dd_derivs :: forall pass. HsDataDefn pass -> HsDeriving pass
    dd_derivs = HsDeriving (GhcPass p)
    derivings }
      | DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p))) -> Bool
    forall a. DataDefnCons a -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null DataDefnCons (LConDecl (GhcPass p))
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    condecls
      = (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    ppDataDefnHeader Maybe (LHsContext (GhcPass p)) -> SDoc
    pp_hdr HsDataDefn (GhcPass p)
    defn SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [GenLocated EpAnnCO (HsDerivingClause (GhcPass p))] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    pp_derivings HsDeriving (GhcPass p)
    [GenLocated EpAnnCO (HsDerivingClause (GhcPass p))]
    derivings

      | Bool
    otherwise
      = SDoc -> Int -> SDoc -> SDoc
    hang ((Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    ppDataDefnHeader Maybe (LHsContext (GhcPass p)) -> SDoc
    pp_hdr HsDataDefn (GhcPass p)
    defn) Int
    2 ([LConDecl (GhcPass p)] -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    [LConDecl (GhcPass p)] -> SDoc
    pp_condecls (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    -> [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))]
    forall a. DataDefnCons a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList DataDefnCons (LConDecl (GhcPass p))
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    condecls) SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ [GenLocated EpAnnCO (HsDerivingClause (GhcPass p))] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    pp_derivings HsDeriving (GhcPass p)
    [GenLocated EpAnnCO (HsDerivingClause (GhcPass p))]
    derivings)
      where
        pp_derivings :: [a] -> SDoc
    pp_derivings [a]
    ds = [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat ((a -> SDoc) -> [a] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [a]
    ds)

    instance OutputableBndrId p
           => Outputable (HsDataDefn (GhcPass p)) where
       ppr :: HsDataDefn (GhcPass p) -> SDoc
    ppr HsDataDefn (GhcPass p)
    d = (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    pp_data_defn (\Maybe (LHsContext (GhcPass p))
    _ -> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "Naked HsDataDefn") HsDataDefn (GhcPass p)
    d

    instance OutputableBndrId p
           => Outputable (StandaloneKindSig (GhcPass p)) where
      ppr :: StandaloneKindSig (GhcPass p) -> SDoc
    ppr (StandaloneKindSig XStandaloneKindSig (GhcPass p)
    _ LIdP (GhcPass p)
    v LHsSigType (GhcPass p)
    ki)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    v) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "::" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsSigType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType (GhcPass p)
    GenLocated SrcSpanAnnA (HsSigType (GhcPass p))
    ki

    pp_condecls :: forall p. OutputableBndrId p => [LConDecl (GhcPass p)] -> SDoc
    pp_condecls :: forall (p :: Pass).
    OutputableBndrId p =>
    [LConDecl (GhcPass p)] -> SDoc
    pp_condecls [LConDecl (GhcPass p)]
    cs
      | [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))] -> Bool
    forall (f :: * -> *) l pass.
    Foldable f =>
    f (GenLocated l (ConDecl pass)) -> Bool
    anyLConIsGadt [LConDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))]
    cs             -- In GADT syntax
      = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "where") Int
    2 ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat ((GenLocated SrcSpanAnnA (ConDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (ConDecl (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LConDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))]
    cs))
      | Bool
    otherwise                    -- In H98 syntax
      = SDoc
    forall doc. IsLine doc => doc
    equals SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep (SDoc -> [SDoc] -> [SDoc]
    forall doc. IsLine doc => doc -> [doc] -> [doc]
    punctuate (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    " |") ((GenLocated SrcSpanAnnA (ConDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (ConDecl (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LConDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (ConDecl (GhcPass p))]
    cs))

    instance (OutputableBndrId p) => Outputable (ConDecl (GhcPass p)) where
        ppr :: ConDecl (GhcPass p) -> SDoc
    ppr = ConDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    ConDecl (GhcPass p) -> SDoc
    pprConDecl

    pprConDecl :: forall p. OutputableBndrId p => ConDecl (GhcPass p) -> SDoc
    pprConDecl :: forall (p :: Pass).
    OutputableBndrId p =>
    ConDecl (GhcPass p) -> SDoc
    pprConDecl (ConDeclH98 { con_name :: forall pass. ConDecl pass -> LIdP pass
    con_name = L Anno (IdGhcP p)
    _ IdGhcP p
    con
                           , con_ex_tvs :: forall pass. ConDecl pass -> [LHsTyVarBndr Specificity pass]
    con_ex_tvs = [LHsTyVarBndr Specificity (GhcPass p)]
    ex_tvs
                           , con_mb_cxt :: forall pass. ConDecl pass -> Maybe (LHsContext pass)
    con_mb_cxt = Maybe (LHsContext (GhcPass p))
    mcxt
                           , con_args :: forall pass. ConDecl pass -> HsConDeclH98Details pass
    con_args = HsConDeclH98Details (GhcPass p)
    args
                           , con_doc :: forall pass. ConDecl pass -> Maybe (LHsDoc pass)
    con_doc = Maybe (LHsDoc (GhcPass p))
    doc })
      = Maybe (LHsDoc (GhcPass p)) -> SDoc -> SDoc
    forall name. Maybe (LHsDoc name) -> SDoc -> SDoc
    pprMaybeWithDoc Maybe (LHsDoc (GhcPass p))
    doc (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
        [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [ HsForAllTelescope (GhcPass p)
    -> Maybe (LHsContext (GhcPass p)) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsForAllTelescope (GhcPass p)
    -> Maybe (LHsContext (GhcPass p)) -> SDoc
    pprHsForAll (EpAnnForallInvis
    -> [LHsTyVarBndr Specificity (GhcPass p)]
    -> HsForAllTelescope (GhcPass p)
    forall (p :: Pass).
    EpAnnForallInvis
    -> [LHsTyVarBndr Specificity (GhcPass p)]
    -> HsForAllTelescope (GhcPass p)
    mkHsForAllInvisTele EpAnnForallInvis
    forall a. NoAnn a => a
    noAnn [LHsTyVarBndr Specificity (GhcPass p)]
    ex_tvs) Maybe (LHsContext (GhcPass p))
    mcxt
            , HsConDetails
      Void
      (HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
      (GenLocated
         SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))])
    -> SDoc
    ppr_details HsConDeclH98Details (GhcPass p)
    HsConDetails
      Void
      (HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
      (GenLocated
         SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))])
    args ]
      where
        -- In ppr_details: let's not print the multiplicities (they are always 1, by
        -- definition) as they do not appear in an actual declaration.
        ppr_details :: HsConDetails
      Void
      (HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p))))
      (GenLocated
         SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))])
    -> SDoc
    ppr_details (InfixCon HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    t1 HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    t2) = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> GenLocated SrcSpanAnnA (HsType (GhcPass p))
    forall pass a. HsScaled pass a -> a
    hsScaledThing HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    t1),
                                             IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprInfixOcc IdGhcP p
    con,
                                             GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> GenLocated SrcSpanAnnA (HsType (GhcPass p))
    forall pass a. HsScaled pass a -> a
    hsScaledThing HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    t2)]
        ppr_details (PrefixCon [Void]
    _ [HsScaled
       (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    tys) = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep (IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc IdGhcP p
    con
                                        SDoc -> [SDoc] -> [SDoc]
    forall a. a -> [a] -> [a]
    : (HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
     -> SDoc)
    -> [HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (HsType (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsType (GhcPass p) -> SDoc
    pprHsType (HsType (GhcPass p) -> SDoc)
    -> (HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
        -> HsType (GhcPass p))
    -> HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> HsType (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> HsType (GhcPass p))
    -> (HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
        -> GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> HsScaled
         (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> HsType (GhcPass p)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
    -> GenLocated SrcSpanAnnA (HsType (GhcPass p))
    forall pass a. HsScaled pass a -> a
    hsScaledThing) [HsScaled
       (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    tys)
        ppr_details (RecCon GenLocated
      SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    fields)  = IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc IdGhcP p
    con
                                     SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [LConDeclField (GhcPass p)] -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    [LConDeclField (GhcPass p)] -> SDoc
    pprConDeclFields (GenLocated
      SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    forall l e. GenLocated l e -> e
    unLoc GenLocated
      SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    fields)

    pprConDecl (ConDeclGADT { con_names :: forall pass. ConDecl pass -> NonEmpty (LIdP pass)
    con_names = NonEmpty (LIdP (GhcPass p))
    cons, con_bndrs :: forall pass. ConDecl pass -> XRec pass (HsOuterSigTyVarBndrs pass)
    con_bndrs = L SrcSpanAnnA
    _ HsOuterSigTyVarBndrs (GhcPass p)
    outer_bndrs
                            , con_mb_cxt :: forall pass. ConDecl pass -> Maybe (LHsContext pass)
    con_mb_cxt = Maybe (LHsContext (GhcPass p))
    mcxt, con_g_args :: forall pass. ConDecl pass -> HsConDeclGADTDetails pass
    con_g_args = HsConDeclGADTDetails (GhcPass p)
    args
                            , con_res_ty :: forall pass. ConDecl pass -> LHsType pass
    con_res_ty = LHsType (GhcPass p)
    res_ty, con_doc :: forall pass. ConDecl pass -> Maybe (LHsDoc pass)
    con_doc = Maybe (LHsDoc (GhcPass p))
    doc })
      = Maybe (LHsDoc (GhcPass p)) -> SDoc -> SDoc
    forall name. Maybe (LHsDoc name) -> SDoc -> SDoc
    pprMaybeWithDoc Maybe (LHsDoc (GhcPass p))
    doc (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [GenLocated (Anno (IdGhcP p)) (IdGhcP p)] -> SDoc
    forall a l. OutputableBndr a => [GenLocated l a] -> SDoc
    ppr_con_names (NonEmpty (GenLocated (Anno (IdGhcP p)) (IdGhcP p))
    -> [GenLocated (Anno (IdGhcP p)) (IdGhcP p)]
    forall a. NonEmpty a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList NonEmpty (LIdP (GhcPass p))
    NonEmpty (GenLocated (Anno (IdGhcP p)) (IdGhcP p))
    cons) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    dcolon
        SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> ([SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [HsOuterSigTyVarBndrs (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsOuterSigTyVarBndrs (GhcPass p) -> SDoc
    pprHsOuterSigTyVarBndrs HsOuterSigTyVarBndrs (GhcPass p)
    outer_bndrs SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe (LHsContext (GhcPass p)) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LHsContext (GhcPass p)) -> SDoc
    pprLHsContext Maybe (LHsContext (GhcPass p))
    mcxt,
                  [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep (HsConDeclGADTDetails (GhcPass p) -> [SDoc]
    forall {p :: Pass}.
    (OutputableBndr (IdGhcP p),
     OutputableBndr (IdGhcP (NoGhcTcPass p)), IsPass p,
     Outputable (GenLocated (Anno (IdGhcP p)) (IdGhcP p)),
     Outputable
       (GenLocated
          (Anno (IdGhcP (NoGhcTcPass p))) (IdGhcP (NoGhcTcPass p)))) =>
    HsConDeclGADTDetails (GhcPass p) -> [SDoc]
    ppr_args HsConDeclGADTDetails (GhcPass p)
    args [SDoc] -> [SDoc] -> [SDoc]
    forall a. [a] -> [a] -> [a]
    ++ [GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType (GhcPass p)
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    res_ty]) ])
      where
        ppr_args :: HsConDeclGADTDetails (GhcPass p) -> [SDoc]
    ppr_args (PrefixConGADT XPrefixConGADT (GhcPass p)
    _ [HsScaled (GhcPass p) (LBangType (GhcPass p))]
    args) = (HsScaled (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
     -> SDoc)
    -> [HsScaled
          (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (\(HsScaled HsArrow (GhcPass p)
    arr GenLocated SrcSpanAnnA (HsType (GhcPass p))
    t) -> GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr GenLocated SrcSpanAnnA (HsType (GhcPass p))
    t SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> HsArrowOf (GenLocated SrcSpanAnnA (HsType (GhcPass p))) (GhcPass p)
    -> SDoc
    forall {pass :: Pass} {mult}.
    (OutputableBndr (IdGhcP pass),
     OutputableBndr (IdGhcP (NoGhcTcPass pass)), IsPass pass,
     Outputable mult,
     Outputable (GenLocated (Anno (IdGhcP pass)) (IdGhcP pass)),
     Outputable
       (GenLocated
          (Anno (IdGhcP (NoGhcTcPass pass))) (IdGhcP (NoGhcTcPass pass)))) =>
    HsArrowOf mult (GhcPass pass) -> SDoc
    ppr_arr HsArrow (GhcPass p)
    HsArrowOf (GenLocated SrcSpanAnnA (HsType (GhcPass p))) (GhcPass p)
    arr) [HsScaled (GhcPass p) (LBangType (GhcPass p))]
    [HsScaled
       (GhcPass p) (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    args
        ppr_args (RecConGADT XRecConGADT (GhcPass p)
    _ XRec (GhcPass p) [LConDeclField (GhcPass p)]
    fields) = [[LConDeclField (GhcPass p)] -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    [LConDeclField (GhcPass p)] -> SDoc
    pprConDeclFields (GenLocated
      SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) [LConDeclField (GhcPass p)]
    GenLocated
      SrcSpanAnnL [GenLocated SrcSpanAnnA (ConDeclField (GhcPass p))]
    fields) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    arrow]

        -- Display linear arrows as unrestricted with -XNoLinearTypes
        -- (cf. dataConDisplayType in Note [Displaying linear fields] in GHC.Core.DataCon)
        ppr_arr :: HsArrowOf mult (GhcPass pass) -> SDoc
    ppr_arr (HsLinearArrow XLinearArrow mult (GhcPass pass)
    _) = (SDocContext -> Bool) -> (Bool -> SDoc) -> SDoc
    forall a. (SDocContext -> a) -> (a -> SDoc) -> SDoc
    sdocOption SDocContext -> Bool
    sdocLinearTypes ((Bool -> SDoc) -> SDoc) -> (Bool -> SDoc) -> SDoc
    forall a b. (a -> b) -> a -> b
    $ \Bool
    show_linear_types ->
                                      if Bool
    show_linear_types then SDoc
    lollipop else SDoc
    arrow
        ppr_arr HsArrowOf mult (GhcPass pass)
    arr = HsArrowOf mult (GhcPass pass) -> SDoc
    forall mult (pass :: Pass).
    (Outputable mult, OutputableBndrId pass) =>
    HsArrowOf mult (GhcPass pass) -> SDoc
    pprHsArrow HsArrowOf mult (GhcPass pass)
    arr

    ppr_con_names :: (OutputableBndr a) => [GenLocated l a] -> SDoc
    ppr_con_names :: forall a l. OutputableBndr a => [GenLocated l a] -> SDoc
    ppr_con_names = (GenLocated l a -> SDoc) -> [GenLocated l a] -> SDoc
    forall a. (a -> SDoc) -> [a] -> SDoc
    pprWithCommas (a -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc (a -> SDoc) -> (GenLocated l a -> a) -> GenLocated l a -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated l a -> a
    forall l e. GenLocated l e -> e
    unLoc)

    {-
    ************************************************************************
    *                                                                      *
                    Instance declarations
    *                                                                      *
    ************************************************************************
    -}

    type instance XCFamEqn    (GhcPass _) r = ([EpToken "("], [EpToken ")"], EpToken "=")
    type instance XXFamEqn    (GhcPass _) r = DataConCantHappen

    ----------------- Class instances -------------

    type instance XCClsInstDecl    GhcPs = ( Maybe (LWarningTxt GhcPs)
                                                 -- The warning of the deprecated instance
                                                 -- See Note [Implementation of deprecated instances]
                                                 -- in GHC.Tc.Solver.Dict
                                           , AnnClsInstDecl
                                           , AnnSortKey DeclTag) -- For sorting the additional annotations
                                            -- TODO:AZ:tidy up
    type instance XCClsInstDecl    GhcRn = Maybe (LWarningTxt GhcRn)
                                               -- The warning of the deprecated instance
                                               -- See Note [Implementation of deprecated instances]
                                               -- in GHC.Tc.Solver.Dict
    type instance XCClsInstDecl    GhcTc = NoExtField

    type instance XXClsInstDecl    (GhcPass _) = DataConCantHappen

    ----------------- Instances of all kinds -------------

    type instance XClsInstD     (GhcPass _) = NoExtField

    type instance XDataFamInstD (GhcPass _) = NoExtField

    type instance XTyFamInstD   GhcPs = NoExtField
    type instance XTyFamInstD   GhcRn = NoExtField
    type instance XTyFamInstD   GhcTc = NoExtField

    type instance XXInstDecl    (GhcPass _) = DataConCantHappen

    data AnnClsInstDecl
      = AnnClsInstDecl {
        AnnClsInstDecl -> EpToken "instance"
    acid_instance :: EpToken "instance",
        AnnClsInstDecl -> EpToken "where"
    acid_where    :: EpToken "where",
        AnnClsInstDecl -> EpToken "{"
    acid_openc    :: EpToken "{",
        AnnClsInstDecl -> [EpToken ";"]
    acid_semis    :: [EpToken ";"],
        AnnClsInstDecl -> EpToken "}"
    acid_closec   :: EpToken "}"
      } deriving Typeable AnnClsInstDecl
    Typeable AnnClsInstDecl =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnClsInstDecl -> c AnnClsInstDecl)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnClsInstDecl)
    -> (AnnClsInstDecl -> Constr)
    -> (AnnClsInstDecl -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnClsInstDecl))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnClsInstDecl))
    -> ((forall b. Data b => b -> b)
        -> AnnClsInstDecl -> AnnClsInstDecl)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> AnnClsInstDecl -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnClsInstDecl -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> AnnClsInstDecl -> m AnnClsInstDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnClsInstDecl -> m AnnClsInstDecl)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnClsInstDecl -> m AnnClsInstDecl)
    -> Data AnnClsInstDecl
    AnnClsInstDecl -> Constr
    AnnClsInstDecl -> DataType
    (forall b. Data b => b -> b) -> AnnClsInstDecl -> AnnClsInstDecl
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> AnnClsInstDecl -> u
    forall u. (forall d. Data d => d -> u) -> AnnClsInstDecl -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnClsInstDecl
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnClsInstDecl -> c AnnClsInstDecl
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnClsInstDecl)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnClsInstDecl)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnClsInstDecl -> c AnnClsInstDecl
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnClsInstDecl -> c AnnClsInstDecl
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnClsInstDecl
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnClsInstDecl
    $ctoConstr :: AnnClsInstDecl -> Constr
    toConstr :: AnnClsInstDecl -> Constr
    $cdataTypeOf :: AnnClsInstDecl -> DataType
    dataTypeOf :: AnnClsInstDecl -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnClsInstDecl)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnClsInstDecl)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnClsInstDecl)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnClsInstDecl)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnClsInstDecl -> AnnClsInstDecl
    gmapT :: (forall b. Data b => b -> b) -> AnnClsInstDecl -> AnnClsInstDecl
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnClsInstDecl -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnClsInstDecl -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnClsInstDecl -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnClsInstDecl -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnClsInstDecl -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnClsInstDecl -> m AnnClsInstDecl
    Data

    instance NoAnn AnnClsInstDecl where
      noAnn :: AnnClsInstDecl
    noAnn = EpToken "instance"
    -> EpToken "where"
    -> EpToken "{"
    -> [EpToken ";"]
    -> EpToken "}"
    -> AnnClsInstDecl
    AnnClsInstDecl EpToken "instance"
    forall a. NoAnn a => a
    noAnn EpToken "where"
    forall a. NoAnn a => a
    noAnn EpToken "{"
    forall a. NoAnn a => a
    noAnn [EpToken ";"]
    forall a. NoAnn a => a
    noAnn EpToken "}"
    forall a. NoAnn a => a
    noAnn

    cidDeprecation :: forall p. IsPass p
                   => ClsInstDecl (GhcPass p)
                   -> Maybe (WarningTxt (GhcPass p))
    cidDeprecation :: forall (p :: Pass).
    IsPass p =>
    ClsInstDecl (GhcPass p) -> Maybe (WarningTxt (GhcPass p))
    cidDeprecation = (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p))
     -> WarningTxt (GhcPass p))
    -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    -> Maybe (WarningTxt (GhcPass p))
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap GenLocated SrcSpanAnnP (WarningTxt (GhcPass p))
    -> WarningTxt (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc (Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
     -> Maybe (WarningTxt (GhcPass p)))
    -> (ClsInstDecl (GhcPass p)
        -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p))))
    -> ClsInstDecl (GhcPass p)
    -> Maybe (WarningTxt (GhcPass p))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GhcPass p
    -> ClsInstDecl (GhcPass p)
    -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    decl_deprecation (forall (p :: Pass). IsPass p => GhcPass p
    ghcPass @p)
      where
        decl_deprecation :: GhcPass p  -> ClsInstDecl (GhcPass p)
                         -> Maybe (LocatedP (WarningTxt (GhcPass p)))
        decl_deprecation :: GhcPass p
    -> ClsInstDecl (GhcPass p)
    -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    decl_deprecation GhcPass p
    GhcPs (ClsInstDecl{ cid_ext :: forall pass. ClsInstDecl pass -> XCClsInstDecl pass
    cid_ext = (Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    depr, AnnClsInstDecl
    _, AnnSortKey DeclTag
    _) } )
          = Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    depr
        decl_deprecation GhcPass p
    GhcRn (ClsInstDecl{ cid_ext :: forall pass. ClsInstDecl pass -> XCClsInstDecl pass
    cid_ext = XCClsInstDecl (GhcPass p)
    depr })
          = Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    XCClsInstDecl (GhcPass p)
    depr
        decl_deprecation GhcPass p
    _ ClsInstDecl (GhcPass p)
    _ = Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    forall a. Maybe a
    Nothing

    instance OutputableBndrId p
           => Outputable (TyFamInstDecl (GhcPass p)) where
      ppr :: TyFamInstDecl (GhcPass p) -> SDoc
    ppr = TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    pprTyFamInstDecl TopLevelFlag
    TopLevel

    pprTyFamInstDecl :: (OutputableBndrId p)
                     => TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    pprTyFamInstDecl :: forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    pprTyFamInstDecl TopLevelFlag
    top_lvl (TyFamInstDecl { tfid_eqn :: forall pass. TyFamInstDecl pass -> TyFamInstEqn pass
    tfid_eqn = TyFamInstEqn (GhcPass p)
    eqn })
       = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TopLevelFlag -> SDoc
    ppr_instance_keyword TopLevelFlag
    top_lvl SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TyFamInstEqn (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TyFamInstEqn (GhcPass p) -> SDoc
    ppr_fam_inst_eqn TyFamInstEqn (GhcPass p)
    eqn

    ppr_instance_keyword :: TopLevelFlag -> SDoc
    ppr_instance_keyword :: TopLevelFlag -> SDoc
    ppr_instance_keyword TopLevelFlag
    TopLevel    = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "instance"
    ppr_instance_keyword TopLevelFlag
    NotTopLevel = SDoc
    forall doc. IsOutput doc => doc
    empty

    pprTyFamDefltDecl :: (OutputableBndrId p)
                      => TyFamDefltDecl (GhcPass p) -> SDoc
    pprTyFamDefltDecl :: forall (p :: Pass).
    OutputableBndrId p =>
    TyFamDefltDecl (GhcPass p) -> SDoc
    pprTyFamDefltDecl = TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    pprTyFamInstDecl TopLevelFlag
    NotTopLevel

    ppr_fam_inst_eqn :: (OutputableBndrId p)
                     => TyFamInstEqn (GhcPass p) -> SDoc
    ppr_fam_inst_eqn :: forall (p :: Pass).
    OutputableBndrId p =>
    TyFamInstEqn (GhcPass p) -> SDoc
    ppr_fam_inst_eqn (FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> LIdP pass
    feqn_tycon  = L Anno (IdGhcP p)
    _ IdGhcP p
    tycon
                             , feqn_bndrs :: forall pass rhs. FamEqn pass rhs -> HsOuterFamEqnTyVarBndrs pass
    feqn_bndrs  = HsOuterFamEqnTyVarBndrs (GhcPass p)
    bndrs
                             , feqn_pats :: forall pass rhs. FamEqn pass rhs -> HsFamEqnPats pass
    feqn_pats   = HsFamEqnPats (GhcPass p)
    pats
                             , feqn_fixity :: forall pass rhs. FamEqn pass rhs -> LexicalFixity
    feqn_fixity = LexicalFixity
    fixity
                             , feqn_rhs :: forall pass rhs. FamEqn pass rhs -> rhs
    feqn_rhs    = LHsType (GhcPass p)
    rhs })
        = IdP (GhcPass p)
    -> HsOuterFamEqnTyVarBndrs (GhcPass p)
    -> HsFamEqnPats (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    IdP (GhcPass p)
    -> HsOuterFamEqnTyVarBndrs (GhcPass p)
    -> HsFamEqnPats (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pprHsFamInstLHS IdP (GhcPass p)
    IdGhcP p
    tycon HsOuterFamEqnTyVarBndrs (GhcPass p)
    bndrs HsFamEqnPats (GhcPass p)
    pats LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    forall a. Maybe a
    Nothing SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    forall doc. IsLine doc => doc
    equals SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType (GhcPass p)
    GenLocated SrcSpanAnnA (HsType (GhcPass p))
    rhs

    instance OutputableBndrId p
           => Outputable (DataFamInstDecl (GhcPass p)) where
      ppr :: DataFamInstDecl (GhcPass p) -> SDoc
    ppr = TopLevelFlag -> DataFamInstDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> DataFamInstDecl (GhcPass p) -> SDoc
    pprDataFamInstDecl TopLevelFlag
    TopLevel

    pprDataFamInstDecl :: (OutputableBndrId p)
                       => TopLevelFlag -> DataFamInstDecl (GhcPass p) -> SDoc
    pprDataFamInstDecl :: forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> DataFamInstDecl (GhcPass p) -> SDoc
    pprDataFamInstDecl TopLevelFlag
    top_lvl (DataFamInstDecl { dfid_eqn :: forall pass. DataFamInstDecl pass -> FamEqn pass (HsDataDefn pass)
    dfid_eqn =
                                (FamEqn { feqn_tycon :: forall pass rhs. FamEqn pass rhs -> LIdP pass
    feqn_tycon  = L Anno (IdGhcP p)
    _ IdGhcP p
    tycon
                                        , feqn_bndrs :: forall pass rhs. FamEqn pass rhs -> HsOuterFamEqnTyVarBndrs pass
    feqn_bndrs  = HsOuterFamEqnTyVarBndrs (GhcPass p)
    bndrs
                                        , feqn_pats :: forall pass rhs. FamEqn pass rhs -> HsFamEqnPats pass
    feqn_pats   = HsFamEqnPats (GhcPass p)
    pats
                                        , feqn_fixity :: forall pass rhs. FamEqn pass rhs -> LexicalFixity
    feqn_fixity = LexicalFixity
    fixity
                                        , feqn_rhs :: forall pass rhs. FamEqn pass rhs -> rhs
    feqn_rhs    = HsDataDefn (GhcPass p)
    defn })})
      = (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    (Maybe (LHsContext (GhcPass p)) -> SDoc)
    -> HsDataDefn (GhcPass p) -> SDoc
    pp_data_defn Maybe (LHsContext (GhcPass p)) -> SDoc
    Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    -> SDoc
    pp_hdr HsDataDefn (GhcPass p)
    defn
      where
        pp_hdr :: Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    -> SDoc
    pp_hdr Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    mctxt = TopLevelFlag -> SDoc
    ppr_instance_keyword TopLevelFlag
    top_lvl
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> IdP (GhcPass p)
    -> HsOuterFamEqnTyVarBndrs (GhcPass p)
    -> HsFamEqnPats (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    IdP (GhcPass p)
    -> HsOuterFamEqnTyVarBndrs (GhcPass p)
    -> HsFamEqnPats (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pprHsFamInstLHS IdP (GhcPass p)
    IdGhcP p
    tycon HsOuterFamEqnTyVarBndrs (GhcPass p)
    bndrs HsFamEqnPats (GhcPass p)
    pats LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    Maybe
      (GenLocated
         SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass p))])
    mctxt
                      -- pp_data_defn pretty-prints the kind sig. See #14817.

    pprDataFamInstFlavour :: DataFamInstDecl (GhcPass p) -> SDoc
    pprDataFamInstFlavour :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> SDoc
    pprDataFamInstFlavour DataFamInstDecl
      { dfid_eqn :: forall pass. DataFamInstDecl pass -> FamEqn pass (HsDataDefn pass)
    dfid_eqn = FamEqn { feqn_rhs :: forall pass rhs. FamEqn pass rhs -> rhs
    feqn_rhs = HsDataDefn { dd_cons :: forall pass. HsDataDefn pass -> DataDefnCons (LConDecl pass)
    dd_cons = DataDefnCons (LConDecl (GhcPass p))
    cons }}}
      = NewOrData -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    -> NewOrData
    forall a. DataDefnCons a -> NewOrData
    dataDefnConsNewOrData DataDefnCons (LConDecl (GhcPass p))
    DataDefnCons (GenLocated SrcSpanAnnA (ConDecl (GhcPass p)))
    cons)

    pprHsFamInstLHS :: (OutputableBndrId p)
       => IdP (GhcPass p)
       -> HsOuterFamEqnTyVarBndrs (GhcPass p)
       -> HsFamEqnPats (GhcPass p)
       -> LexicalFixity
       -> Maybe (LHsContext (GhcPass p))
       -> SDoc
    pprHsFamInstLHS :: forall (p :: Pass).
    OutputableBndrId p =>
    IdP (GhcPass p)
    -> HsOuterFamEqnTyVarBndrs (GhcPass p)
    -> HsFamEqnPats (GhcPass p)
    -> LexicalFixity
    -> Maybe (LHsContext (GhcPass p))
    -> SDoc
    pprHsFamInstLHS IdP (GhcPass p)
    thing HsOuterFamEqnTyVarBndrs (GhcPass p)
    bndrs HsFamEqnPats (GhcPass p)
    typats LexicalFixity
    fixity Maybe (LHsContext (GhcPass p))
    mb_ctxt
       = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [ HsOuterFamEqnTyVarBndrs (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsOuterFamEqnTyVarBndrs (GhcPass p) -> SDoc
    pprHsOuterFamEqnTyVarBndrs HsOuterFamEqnTyVarBndrs (GhcPass p)
    bndrs
              , Maybe (LHsContext (GhcPass p)) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LHsContext (GhcPass p)) -> SDoc
    pprLHsContext Maybe (LHsContext (GhcPass p))
    mb_ctxt
              , IdGhcP p
    -> LexicalFixity
    -> [HsArg
          (GhcPass p)
          (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
          (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    -> SDoc
    forall id tm ty (p :: Pass).
    (OutputableBndr id, Outputable tm, Outputable ty) =>
    id -> LexicalFixity -> [HsArg (GhcPass p) tm ty] -> SDoc
    pprHsArgsApp IdP (GhcPass p)
    IdGhcP p
    thing LexicalFixity
    fixity HsFamEqnPats (GhcPass p)
    [HsArg
       (GhcPass p)
       (GenLocated SrcSpanAnnA (HsType (GhcPass p)))
       (GenLocated SrcSpanAnnA (HsType (GhcPass p)))]
    typats ]

    instance OutputableBndrId p
           => Outputable (ClsInstDecl (GhcPass p)) where
        ppr :: ClsInstDecl (GhcPass p) -> SDoc
    ppr (cid :: ClsInstDecl (GhcPass p)
    cid@ClsInstDecl { cid_poly_ty :: forall pass. ClsInstDecl pass -> LHsSigType pass
    cid_poly_ty = LHsSigType (GhcPass p)
    inst_ty, cid_binds :: forall pass. ClsInstDecl pass -> LHsBinds pass
    cid_binds = LHsBinds (GhcPass p)
    binds
                             , cid_sigs :: forall pass. ClsInstDecl pass -> [LSig pass]
    cid_sigs = [LSig (GhcPass p)]
    sigs, cid_tyfam_insts :: forall pass. ClsInstDecl pass -> [LTyFamInstDecl pass]
    cid_tyfam_insts = [LTyFamInstDecl (GhcPass p)]
    ats
                             , cid_overlap_mode :: forall pass. ClsInstDecl pass -> Maybe (XRec pass OverlapMode)
    cid_overlap_mode = Maybe (XRec (GhcPass p) OverlapMode)
    mbOverlap
                             , cid_datafam_insts :: forall pass. ClsInstDecl pass -> [LDataFamInstDecl pass]
    cid_datafam_insts = [LDataFamInstDecl (GhcPass p)]
    adts })
          | [GenLocated SrcSpanAnnA (Sig (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LSig (GhcPass p)]
    [GenLocated SrcSpanAnnA (Sig (GhcPass p))]
    sigs, [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LTyFamInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))]
    ats, [GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LDataFamInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))]
    adts, [GenLocated SrcSpanAnnA (HsBindLR (GhcPass p) (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null LHsBinds (GhcPass p)
    [GenLocated SrcSpanAnnA (HsBindLR (GhcPass p) (GhcPass p))]
    binds  -- No "where" part
          = SDoc
    top_matter

          | Bool
    otherwise       -- Laid out
          = [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ SDoc
    top_matter SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "where"
                 , Int -> SDoc -> SDoc
    nest Int
    2 (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [SDoc] -> SDoc
    pprDeclList ([SDoc] -> SDoc) -> [SDoc] -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                   (GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
    pprTyFamInstDecl TopLevelFlag
    NotTopLevel (TyFamInstDecl (GhcPass p) -> SDoc)
    -> (GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))
        -> TyFamInstDecl (GhcPass p))
    -> GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))
    -> TyFamInstDecl (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc)   [LTyFamInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (TyFamInstDecl (GhcPass p))]
    ats [SDoc] -> [SDoc] -> [SDoc]
    forall a. [a] -> [a] -> [a]
    ++
                   (GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (TopLevelFlag -> DataFamInstDecl (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    TopLevelFlag -> DataFamInstDecl (GhcPass p) -> SDoc
    pprDataFamInstDecl TopLevelFlag
    NotTopLevel (DataFamInstDecl (GhcPass p) -> SDoc)
    -> (GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))
        -> DataFamInstDecl (GhcPass p))
    -> GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))
    -> DataFamInstDecl (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) [LDataFamInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))]
    adts [SDoc] -> [SDoc] -> [SDoc]
    forall a. [a] -> [a] -> [a]
    ++
                   LHsBinds (GhcPass p) -> [LSig (GhcPass p)] -> [SDoc]
    forall (idL :: Pass) (idR :: Pass) (id2 :: Pass).
    (OutputableBndrId idL, OutputableBndrId idR,
     OutputableBndrId id2) =>
    LHsBindsLR (GhcPass idL) (GhcPass idR)
    -> [LSig (GhcPass id2)] -> [SDoc]
    pprLHsBindsForUser LHsBinds (GhcPass p)
    binds [LSig (GhcPass p)]
    sigs ]
          where
            top_matter :: SDoc
    top_matter = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "instance" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    -> (WarningTxt (GhcPass p) -> SDoc)
    -> Maybe (WarningTxt (GhcPass p))
    -> SDoc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe SDoc
    forall doc. IsOutput doc => doc
    empty WarningTxt (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (ClsInstDecl (GhcPass p) -> Maybe (WarningTxt (GhcPass p))
    forall (p :: Pass).
    IsPass p =>
    ClsInstDecl (GhcPass p) -> Maybe (WarningTxt (GhcPass p))
    cidDeprecation ClsInstDecl (GhcPass p)
    cid)
                                         SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe (LocatedP OverlapMode) -> SDoc
    ppOverlapPragma Maybe (XRec (GhcPass p) OverlapMode)
    Maybe (LocatedP OverlapMode)
    mbOverlap
                                         SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsSigType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType (GhcPass p)
    GenLocated SrcSpanAnnA (HsSigType (GhcPass p))
    inst_ty

    ppDerivStrategy :: OutputableBndrId p
                    => Maybe (LDerivStrategy (GhcPass p)) -> SDoc
    ppDerivStrategy :: forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LDerivStrategy (GhcPass p)) -> SDoc
    ppDerivStrategy Maybe (LDerivStrategy (GhcPass p))
    mb =
      case Maybe (LDerivStrategy (GhcPass p))
    mb of
        Maybe (LDerivStrategy (GhcPass p))
    Nothing       -> SDoc
    forall doc. IsOutput doc => doc
    empty
        Just (L EpAnnCO
    _ DerivStrategy (GhcPass p)
    ds) -> DerivStrategy (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DerivStrategy (GhcPass p)
    ds

    ppOverlapPragma :: Maybe (LocatedP OverlapMode) -> SDoc
    ppOverlapPragma :: Maybe (LocatedP OverlapMode) -> SDoc
    ppOverlapPragma Maybe (LocatedP OverlapMode)
    mb =
      case Maybe (LocatedP OverlapMode)
    mb of
        Maybe (LocatedP OverlapMode)
    Nothing           -> SDoc
    forall doc. IsOutput doc => doc
    empty
        Just (L SrcSpanAnnP
    _ (NoOverlap SourceText
    s))    -> SourceText -> String -> SDoc
    forall {doc}. IsLine doc => SourceText -> String -> doc
    maybe_stext SourceText
    s String
    "{-# NO_OVERLAP #-}"
        Just (L SrcSpanAnnP
    _ (Overlappable SourceText
    s)) -> SourceText -> String -> SDoc
    forall {doc}. IsLine doc => SourceText -> String -> doc
    maybe_stext SourceText
    s String
    "{-# OVERLAPPABLE #-}"
        Just (L SrcSpanAnnP
    _ (Overlapping SourceText
    s))  -> SourceText -> String -> SDoc
    forall {doc}. IsLine doc => SourceText -> String -> doc
    maybe_stext SourceText
    s String
    "{-# OVERLAPPING #-}"
        Just (L SrcSpanAnnP
    _ (Overlaps SourceText
    s))     -> SourceText -> String -> SDoc
    forall {doc}. IsLine doc => SourceText -> String -> doc
    maybe_stext SourceText
    s String
    "{-# OVERLAPS #-}"
        Just (L SrcSpanAnnP
    _ (Incoherent SourceText
    s))   -> SourceText -> String -> SDoc
    forall {doc}. IsLine doc => SourceText -> String -> doc
    maybe_stext SourceText
    s String
    "{-# INCOHERENT #-}"
        Just (L SrcSpanAnnP
    _ (NonCanonical SourceText
    s)) -> SourceText -> String -> SDoc
    forall {doc}. IsLine doc => SourceText -> String -> doc
    maybe_stext SourceText
    s String
    "{-# INCOHERENT #-}" -- No surface syntax for NONCANONICAL yet
      where
        maybe_stext :: SourceText -> String -> doc
    maybe_stext SourceText
    NoSourceText     String
    alt = String -> doc
    forall doc. IsLine doc => String -> doc
    text String
    alt
        maybe_stext (SourceText FastString
    src) String
    _   = FastString -> doc
    forall doc. IsLine doc => FastString -> doc
    ftext FastString
    src doc -> doc -> doc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> doc
    forall doc. IsLine doc => String -> doc
    text String
    "#-}"

    instance (OutputableBndrId p) => Outputable (InstDecl (GhcPass p)) where
        ppr :: InstDecl (GhcPass p) -> SDoc
    ppr (ClsInstD     { cid_inst :: forall pass. InstDecl pass -> ClsInstDecl pass
    cid_inst  = ClsInstDecl (GhcPass p)
    decl }) = ClsInstDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ClsInstDecl (GhcPass p)
    decl
        ppr (TyFamInstD   { tfid_inst :: forall pass. InstDecl pass -> TyFamInstDecl pass
    tfid_inst = TyFamInstDecl (GhcPass p)
    decl }) = TyFamInstDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyFamInstDecl (GhcPass p)
    decl
        ppr (DataFamInstD { dfid_inst :: forall pass. InstDecl pass -> DataFamInstDecl pass
    dfid_inst = DataFamInstDecl (GhcPass p)
    decl }) = DataFamInstDecl (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DataFamInstDecl (GhcPass p)
    decl

    -- Extract the declarations of associated data types from an instance

    instDeclDataFamInsts :: [LInstDecl (GhcPass p)] -> [DataFamInstDecl (GhcPass p)]
    instDeclDataFamInsts :: forall (p :: Pass).
    [LInstDecl (GhcPass p)] -> [DataFamInstDecl (GhcPass p)]
    instDeclDataFamInsts [LInstDecl (GhcPass p)]
    inst_decls
      = (GenLocated SrcSpanAnnA (InstDecl (GhcPass p))
     -> [DataFamInstDecl (GhcPass p)])
    -> [GenLocated SrcSpanAnnA (InstDecl (GhcPass p))]
    -> [DataFamInstDecl (GhcPass p)]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap LInstDecl (GhcPass p) -> [DataFamInstDecl (GhcPass p)]
    GenLocated SrcSpanAnnA (InstDecl (GhcPass p))
    -> [DataFamInstDecl (GhcPass p)]
    forall (p :: Pass).
    LInstDecl (GhcPass p) -> [DataFamInstDecl (GhcPass p)]
    do_one [LInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (InstDecl (GhcPass p))]
    inst_decls
      where
        do_one :: LInstDecl (GhcPass p) -> [DataFamInstDecl (GhcPass p)]
        do_one :: forall (p :: Pass).
    LInstDecl (GhcPass p) -> [DataFamInstDecl (GhcPass p)]
    do_one (L SrcSpanAnnA
    _ (ClsInstD { cid_inst :: forall pass. InstDecl pass -> ClsInstDecl pass
    cid_inst = ClsInstDecl { cid_datafam_insts :: forall pass. ClsInstDecl pass -> [LDataFamInstDecl pass]
    cid_datafam_insts = [LDataFamInstDecl (GhcPass p)]
    fam_insts } }))
          = (GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))
     -> DataFamInstDecl (GhcPass p))
    -> [GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))]
    -> [DataFamInstDecl (GhcPass p)]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))
    -> DataFamInstDecl (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc [LDataFamInstDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (DataFamInstDecl (GhcPass p))]
    fam_insts
        do_one (L SrcSpanAnnA
    _ (DataFamInstD { dfid_inst :: forall pass. InstDecl pass -> DataFamInstDecl pass
    dfid_inst = DataFamInstDecl (GhcPass p)
    fam_inst }))      = [DataFamInstDecl (GhcPass p)
    fam_inst]
        do_one (L SrcSpanAnnA
    _ (TyFamInstD {}))                              = []

    -- | Convert a 'NewOrData' to a 'TyConFlavour'
    newOrDataToFlavour :: NewOrData -> TyConFlavour tc
    newOrDataToFlavour :: forall tc. NewOrData -> TyConFlavour tc
    newOrDataToFlavour NewOrData
    NewType  = TyConFlavour tc
    forall tc. TyConFlavour tc
    NewtypeFlavour
    newOrDataToFlavour NewOrData
    DataType = TyConFlavour tc
    forall tc. TyConFlavour tc
    DataTypeFlavour

    instance Outputable NewOrData where
      ppr :: NewOrData -> SDoc
    ppr NewOrData
    NewType  = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "newtype"
      ppr NewOrData
    DataType = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "data"

    -- At the moment we only call this with @f = '[]'@ and @f = 'DataDefnCons'@.
    anyLConIsGadt :: Foldable f => f (GenLocated l (ConDecl pass)) -> Bool
    anyLConIsGadt :: forall (f :: * -> *) l pass.
    Foldable f =>
    f (GenLocated l (ConDecl pass)) -> Bool
    anyLConIsGadt f (GenLocated l (ConDecl pass))
    xs = case f (GenLocated l (ConDecl pass)) -> [GenLocated l (ConDecl pass)]
    forall a. f a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList f (GenLocated l (ConDecl pass))
    xs of
        L l
    _ ConDeclGADT {} : [GenLocated l (ConDecl pass)]
    _ -> Bool
    True
        [GenLocated l (ConDecl pass)]
    _ -> Bool
    False
    {-# SPECIALIZE anyLConIsGadt :: [GenLocated l (ConDecl pass)] -> Bool #-}
    {-# SPECIALIZE anyLConIsGadt :: DataDefnCons (GenLocated l (ConDecl pass)) -> Bool #-}

    {-
    ************************************************************************
    *                                                                      *
    \subsection[DerivDecl]{A stand-alone instance deriving declaration}
    *                                                                      *
    ************************************************************************
    -}

    type instance XCDerivDecl    GhcPs = ( Maybe (LWarningTxt GhcPs)
                                               -- The warning of the deprecated derivation
                                               -- See Note [Implementation of deprecated instances]
                                               -- in GHC.Tc.Solver.Dict
                                         , AnnDerivDecl )
    type instance XCDerivDecl    GhcRn = ( Maybe (LWarningTxt GhcRn)
                                               -- The warning of the deprecated derivation
                                               -- See Note [Implementation of deprecated instances]
                                               -- in GHC.Tc.Solver.Dict
                                         , AnnDerivDecl )
    type instance XCDerivDecl    GhcTc = AnnDerivDecl
    type instance XXDerivDecl    (GhcPass _) = DataConCantHappen

    type AnnDerivDecl = (EpToken "deriving", EpToken "instance")

    derivDeprecation :: forall p. IsPass p
                   => DerivDecl (GhcPass p)
                   -> Maybe (WarningTxt (GhcPass p))
    derivDeprecation :: forall (p :: Pass).
    IsPass p =>
    DerivDecl (GhcPass p) -> Maybe (WarningTxt (GhcPass p))
    derivDeprecation = (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p))
     -> WarningTxt (GhcPass p))
    -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    -> Maybe (WarningTxt (GhcPass p))
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap GenLocated SrcSpanAnnP (WarningTxt (GhcPass p))
    -> WarningTxt (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc (Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
     -> Maybe (WarningTxt (GhcPass p)))
    -> (DerivDecl (GhcPass p)
        -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p))))
    -> DerivDecl (GhcPass p)
    -> Maybe (WarningTxt (GhcPass p))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GhcPass p
    -> DerivDecl (GhcPass p)
    -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    decl_deprecation (forall (p :: Pass). IsPass p => GhcPass p
    ghcPass @p)
      where
        decl_deprecation :: GhcPass p  -> DerivDecl (GhcPass p)
                         -> Maybe (LocatedP (WarningTxt (GhcPass p)))
        decl_deprecation :: GhcPass p
    -> DerivDecl (GhcPass p)
    -> Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    decl_deprecation GhcPass p
    GhcPs (DerivDecl{ deriv_ext :: forall pass. DerivDecl pass -> XCDerivDecl pass
    deriv_ext = (Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    depr, AnnDerivDecl
    _) })
          = Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    depr
        decl_deprecation GhcPass p
    GhcRn (DerivDecl{ deriv_ext :: forall pass. DerivDecl pass -> XCDerivDecl pass
    deriv_ext = (Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    depr, AnnDerivDecl
    _) })
          = Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    depr
        decl_deprecation GhcPass p
    _ DerivDecl (GhcPass p)
    _ = Maybe (GenLocated SrcSpanAnnP (WarningTxt (GhcPass p)))
    forall a. Maybe a
    Nothing

    instance OutputableBndrId p
           => Outputable (DerivDecl (GhcPass p)) where
        ppr :: DerivDecl (GhcPass p) -> SDoc
    ppr (deriv :: DerivDecl (GhcPass p)
    deriv@DerivDecl { deriv_type :: forall pass. DerivDecl pass -> LHsSigWcType pass
    deriv_type = LHsSigWcType (GhcPass p)
    ty
                       , deriv_strategy :: forall pass. DerivDecl pass -> Maybe (LDerivStrategy pass)
    deriv_strategy = Maybe (LDerivStrategy (GhcPass p))
    ds
                       , deriv_overlap_mode :: forall pass. DerivDecl pass -> Maybe (XRec pass OverlapMode)
    deriv_overlap_mode = Maybe (XRec (GhcPass p) OverlapMode)
    o })
            = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "deriving"
                   , Maybe (LDerivStrategy (GhcPass p)) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Maybe (LDerivStrategy (GhcPass p)) -> SDoc
    ppDerivStrategy Maybe (LDerivStrategy (GhcPass p))
    ds
                   , String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "instance"
                   , SDoc
    -> (WarningTxt (GhcPass p) -> SDoc)
    -> Maybe (WarningTxt (GhcPass p))
    -> SDoc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe SDoc
    forall doc. IsOutput doc => doc
    empty WarningTxt (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (DerivDecl (GhcPass p) -> Maybe (WarningTxt (GhcPass p))
    forall (p :: Pass).
    IsPass p =>
    DerivDecl (GhcPass p) -> Maybe (WarningTxt (GhcPass p))
    derivDeprecation DerivDecl (GhcPass p)
    deriv)
                   , Maybe (LocatedP OverlapMode) -> SDoc
    ppOverlapPragma Maybe (XRec (GhcPass p) OverlapMode)
    Maybe (LocatedP OverlapMode)
    o
                   , HsWildCardBndrs
      (GhcPass p) (GenLocated SrcSpanAnnA (HsSigType (GhcPass p)))
    -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigWcType (GhcPass p)
    HsWildCardBndrs
      (GhcPass p) (GenLocated SrcSpanAnnA (HsSigType (GhcPass p)))
    ty ]

    {-
    ************************************************************************
    *                                                                      *
                    Deriving strategies
    *                                                                      *
    ************************************************************************
    -}

    type instance XStockStrategy    GhcPs = EpToken "stock"
    type instance XStockStrategy    GhcRn = NoExtField
    type instance XStockStrategy    GhcTc = NoExtField

    type instance XAnyClassStrategy GhcPs = EpToken "anyclass"
    type instance XAnyClassStrategy GhcRn = NoExtField
    type instance XAnyClassStrategy GhcTc = NoExtField

    type instance XNewtypeStrategy  GhcPs = EpToken "newtype"
    type instance XNewtypeStrategy  GhcRn = NoExtField
    type instance XNewtypeStrategy  GhcTc = NoExtField

    type instance XViaStrategy GhcPs = XViaStrategyPs
    type instance XViaStrategy GhcRn = LHsSigType GhcRn
    type instance XViaStrategy GhcTc = Type

    data XViaStrategyPs = XViaStrategyPs (EpToken "via") (LHsSigType GhcPs)

    instance OutputableBndrId p
            => Outputable (DerivStrategy (GhcPass p)) where
        ppr :: DerivStrategy (GhcPass p) -> SDoc
    ppr (StockStrategy    XStockStrategy (GhcPass p)
    _) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "stock"
        ppr (AnyclassStrategy XAnyClassStrategy (GhcPass p)
    _) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "anyclass"
        ppr (NewtypeStrategy  XNewtypeStrategy (GhcPass p)
    _) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "newtype"
        ppr (ViaStrategy XViaStrategy (GhcPass p)
    ty)     = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "via" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> case forall (p :: Pass). IsPass p => GhcPass p
    ghcPass @p of
                                                    GhcPass p
    GhcPs -> XViaStrategyPs -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr XViaStrategy (GhcPass p)
    XViaStrategyPs
    ty
                                                    GhcPass p
    GhcRn -> GenLocated SrcSpanAnnA (HsSigType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr XViaStrategy (GhcPass p)
    GenLocated SrcSpanAnnA (HsSigType GhcRn)
    ty
                                                    GhcPass p
    GhcTc -> Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr XViaStrategy (GhcPass p)
    Type
    ty

    instance Outputable XViaStrategyPs where
        ppr :: XViaStrategyPs -> SDoc
    ppr (XViaStrategyPs EpToken "via"
    _ LHsSigType GhcPs
    t) = GenLocated SrcSpanAnnA (HsSigType GhcPs) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType GhcPs
    GenLocated SrcSpanAnnA (HsSigType GhcPs)
    t

    -- | Eliminate a 'DerivStrategy'.
    foldDerivStrategy :: (p ~ GhcPass pass)
                      => r -> (XViaStrategy p -> r) -> DerivStrategy p -> r
    foldDerivStrategy :: forall p (pass :: Pass) r.
    (p ~ GhcPass pass) =>
    r -> (XViaStrategy p -> r) -> DerivStrategy p -> r
    foldDerivStrategy r
    other XViaStrategy p -> r
    _   (StockStrategy    XStockStrategy p
    _) = r
    other
    foldDerivStrategy r
    other XViaStrategy p -> r
    _   (AnyclassStrategy XAnyClassStrategy p
    _) = r
    other
    foldDerivStrategy r
    other XViaStrategy p -> r
    _   (NewtypeStrategy  XNewtypeStrategy p
    _) = r
    other
    foldDerivStrategy r
    _     XViaStrategy p -> r
    via (ViaStrategy XViaStrategy p
    t)  = XViaStrategy p -> r
    via XViaStrategy p
    t

    -- | Map over the @via@ type if dealing with 'ViaStrategy'. Otherwise,
    -- return the 'DerivStrategy' unchanged.
    mapDerivStrategy :: (p ~ GhcPass pass)
                     => (XViaStrategy p -> XViaStrategy p)
                     -> DerivStrategy p -> DerivStrategy p
    mapDerivStrategy :: forall p (pass :: Pass).
    (p ~ GhcPass pass) =>
    (XViaStrategy p -> XViaStrategy p)
    -> DerivStrategy p -> DerivStrategy p
    mapDerivStrategy XViaStrategy p -> XViaStrategy p
    f DerivStrategy p
    ds = DerivStrategy p
    -> (XViaStrategy p -> DerivStrategy p)
    -> DerivStrategy p
    -> DerivStrategy p
    forall p (pass :: Pass) r.
    (p ~ GhcPass pass) =>
    r -> (XViaStrategy p -> r) -> DerivStrategy p -> r
    foldDerivStrategy DerivStrategy p
    ds (XViaStrategy p -> DerivStrategy p
    XViaStrategy (GhcPass pass) -> DerivStrategy p
    forall pass. XViaStrategy pass -> DerivStrategy pass
    ViaStrategy (XViaStrategy (GhcPass pass) -> DerivStrategy p)
    -> (XViaStrategy (GhcPass pass) -> XViaStrategy (GhcPass pass))
    -> XViaStrategy (GhcPass pass)
    -> DerivStrategy p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . XViaStrategy p -> XViaStrategy p
    XViaStrategy (GhcPass pass) -> XViaStrategy (GhcPass pass)
    f) DerivStrategy p
    ds

    {-
    ************************************************************************
    *                                                                      *
    \subsection[DefaultDecl]{A @default@ declaration}
    *                                                                      *
    ************************************************************************
    -}

    type instance XCDefaultDecl    GhcPs = (EpToken "default", EpToken "(", EpToken ")")
    type instance XCDefaultDecl    GhcRn = NoExtField
    type instance XCDefaultDecl    GhcTc = NoExtField

    type instance XXDefaultDecl    (GhcPass _) = DataConCantHappen

    instance OutputableBndrId p
           => Outputable (DefaultDecl (GhcPass p)) where
        ppr :: DefaultDecl (GhcPass p) -> SDoc
    ppr (DefaultDecl XCDefaultDecl (GhcPass p)
    _ Maybe (LIdP (GhcPass p))
    cl [LHsType (GhcPass p)]
    tys)
          = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "default" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> (SDoc -> SDoc)
    -> (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc -> SDoc)
    -> Maybe (GenLocated (Anno (IdGhcP p)) (IdGhcP p))
    -> SDoc
    -> SDoc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe SDoc -> SDoc
    forall a. a -> a
    id (SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    (<+>) (SDoc -> SDoc -> SDoc)
    -> (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc)
    -> GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    -> SDoc
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr) Maybe (LIdP (GhcPass p))
    Maybe (GenLocated (Anno (IdGhcP p)) (IdGhcP p))
    cl (SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens ([GenLocated SrcSpanAnnA (HsType (GhcPass p))] -> SDoc
    forall a. Outputable a => [a] -> SDoc
    interpp'SP [LHsType (GhcPass p)]
    [GenLocated SrcSpanAnnA (HsType (GhcPass p))]
    tys))

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Foreign function interface declaration}
    *                                                                      *
    ************************************************************************
    -}

    type instance XForeignImport   GhcPs = (EpToken "foreign", EpToken "import", TokDcolon)
    type instance XForeignImport   GhcRn = NoExtField
    type instance XForeignImport   GhcTc = Coercion

    type instance XForeignExport   GhcPs = (EpToken "foreign", EpToken "export", TokDcolon)
    type instance XForeignExport   GhcRn = NoExtField
    type instance XForeignExport   GhcTc = Coercion

    type instance XXForeignDecl    (GhcPass _) = DataConCantHappen

    type instance XCImport (GhcPass _) = LocatedE SourceText -- original source text for the C entity
    type instance XXForeignImport  (GhcPass _) = DataConCantHappen

    type instance XCExport (GhcPass _) = LocatedE SourceText -- original source text for the C entity
    type instance XXForeignExport  (GhcPass _) = DataConCantHappen

    -- pretty printing of foreign declarations

    instance OutputableBndrId p
           => Outputable (ForeignDecl (GhcPass p)) where
      ppr :: ForeignDecl (GhcPass p) -> SDoc
    ppr (ForeignImport { fd_name :: forall pass. ForeignDecl pass -> LIdP pass
    fd_name = LIdP (GhcPass p)
    n, fd_sig_ty :: forall pass. ForeignDecl pass -> LHsSigType pass
    fd_sig_ty = LHsSigType (GhcPass p)
    ty, fd_fi :: forall pass. ForeignDecl pass -> ForeignImport pass
    fd_fi = ForeignImport (GhcPass p)
    fimport })
        = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "foreign import" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> ForeignImport (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ForeignImport (GhcPass p)
    fimport SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    n)
             Int
    2 (SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsSigType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType (GhcPass p)
    GenLocated SrcSpanAnnA (HsSigType (GhcPass p))
    ty)
      ppr (ForeignExport { fd_name :: forall pass. ForeignDecl pass -> LIdP pass
    fd_name = LIdP (GhcPass p)
    n, fd_sig_ty :: forall pass. ForeignDecl pass -> LHsSigType pass
    fd_sig_ty = LHsSigType (GhcPass p)
    ty, fd_fe :: forall pass. ForeignDecl pass -> ForeignExport pass
    fd_fe = ForeignExport (GhcPass p)
    fexport }) =
        SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "foreign export" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> ForeignExport (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ForeignExport (GhcPass p)
    fexport SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    n)
           Int
    2 (SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated SrcSpanAnnA (HsSigType (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType (GhcPass p)
    GenLocated SrcSpanAnnA (HsSigType (GhcPass p))
    ty)

    instance OutputableBndrId p
           => Outputable (ForeignImport (GhcPass p)) where
      ppr :: ForeignImport (GhcPass p) -> SDoc
    ppr (CImport (L EpaLocation
    _ SourceText
    srcText) XRec (GhcPass p) CCallConv
    cconv XRec (GhcPass p) Safety
    safety Maybe Header
    mHeader CImportSpec
    spec) =
        GenLocated EpaLocation CCallConv -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr XRec (GhcPass p) CCallConv
    GenLocated EpaLocation CCallConv
    cconv SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> GenLocated EpaLocation Safety -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr XRec (GhcPass p) Safety
    GenLocated EpaLocation Safety
    safety
          SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SourceText -> SDoc -> SDoc
    pprWithSourceText SourceText
    srcText (CImportSpec -> String -> SDoc
    pprCEntity CImportSpec
    spec String
    "")
        where
          pp_hdr :: SDoc
    pp_hdr = case Maybe Header
    mHeader of
                   Maybe Header
    Nothing -> SDoc
    forall doc. IsOutput doc => doc
    empty
                   Just (Header SourceText
    _ FastString
    header) -> FastString -> SDoc
    forall doc. IsLine doc => FastString -> doc
    ftext FastString
    header

          pprCEntity :: CImportSpec -> String -> SDoc
    pprCEntity (CLabel FastString
    lbl) String
    _ =
            SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    doubleQuotes (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "static" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_hdr SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '&' SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> FastString -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FastString
    lbl
          pprCEntity (CFunction (StaticTarget SourceText
    st FastString
    _lbl Maybe Unit
    _ Bool
    isFun)) String
    src =
            if Bool
    dqNeeded then SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    doubleQuotes SDoc
    ce else SDoc
    forall doc. IsOutput doc => doc
    empty
              where
                dqNeeded :: Bool
    dqNeeded = (Int -> String -> String
    forall a. Int -> [a] -> [a]
    take Int
    6 String
    src String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "static")
                        Bool -> Bool -> Bool
    || Maybe Header -> Bool
    forall a. Maybe a -> Bool
    isJust Maybe Header
    mHeader
                        Bool -> Bool -> Bool
    || Bool -> Bool
    not Bool
    isFun
                        Bool -> Bool -> Bool
    || SourceText
    st SourceText -> SourceText -> Bool
    forall a. Eq a => a -> a -> Bool
    /= SourceText
    NoSourceText
                ce :: SDoc
    ce =
                      -- We may need to drop leading spaces first
                      (if Int -> String -> String
    forall a. Int -> [a] -> [a]
    take Int
    6 String
    src String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "static" then String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "static" else SDoc
    forall doc. IsOutput doc => doc
    empty)
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    pp_hdr
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> (if Bool
    isFun then SDoc
    forall doc. IsOutput doc => doc
    empty else String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "value")
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> (SourceText -> SDoc -> SDoc
    pprWithSourceText SourceText
    st SDoc
    forall doc. IsOutput doc => doc
    empty)
          pprCEntity (CFunction CCallTarget
    DynamicTarget) String
    _ =
            SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    doubleQuotes (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "dynamic"
          pprCEntity CImportSpec
    CWrapper String
    _ = SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    doubleQuotes (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "wrapper"

    instance OutputableBndrId p
           => Outputable (ForeignExport (GhcPass p)) where
      ppr :: ForeignExport (GhcPass p) -> SDoc
    ppr (CExport XCExport (GhcPass p)
    _ (L EpaLocation
    _ (CExportStatic SourceText
    _ FastString
    lbl CCallConv
    cconv))) =
        CCallConv -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr CCallConv
    cconv SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '"' SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> FastString -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FastString
    lbl SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '"'

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Rewrite rules}
    *                                                                      *
    ************************************************************************
    -}

    type instance XCRuleDecls    GhcPs = ((EpaLocation, EpToken "#-}"), SourceText)
    type instance XCRuleDecls    GhcRn = SourceText
    type instance XCRuleDecls    GhcTc = SourceText

    type instance XXRuleDecls    (GhcPass _) = DataConCantHappen

    type instance XHsRule       GhcPs = (HsRuleAnn, SourceText)
    type instance XHsRule       GhcRn = (HsRuleRn, SourceText)
    type instance XHsRule       GhcTc = (HsRuleRn, SourceText)

    data HsRuleRn = HsRuleRn NameSet NameSet -- Free-vars from the LHS and RHS
      deriving Typeable HsRuleRn
    Typeable HsRuleRn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsRuleRn)
    -> (HsRuleRn -> Constr)
    -> (HsRuleRn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn))
    -> ((forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsRuleRn -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn)
    -> Data HsRuleRn
    HsRuleRn -> Constr
    HsRuleRn -> DataType
    (forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u
    forall u. (forall d. Data d => d -> u) -> HsRuleRn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRuleRn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRuleRn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRuleRn
    $ctoConstr :: HsRuleRn -> Constr
    toConstr :: HsRuleRn -> Constr
    $cdataTypeOf :: HsRuleRn -> DataType
    dataTypeOf :: HsRuleRn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn)
    $cgmapT :: (forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn
    gmapT :: (forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsRuleRn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsRuleRn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn
    Data

    type instance XXRuleDecl    (GhcPass _) = DataConCantHappen

    data HsRuleAnn
      = HsRuleAnn
           { HsRuleAnn -> Maybe (TokForall, EpToken ".")
    ra_tyanns :: Maybe (TokForall, EpToken ".")
           , HsRuleAnn -> Maybe (TokForall, EpToken ".")
    ra_tmanns :: Maybe (TokForall, EpToken ".")
           , HsRuleAnn -> EpToken "="
    ra_equal  :: EpToken "="
           , HsRuleAnn -> ActivationAnn
    ra_rest :: ActivationAnn
           } deriving (Typeable HsRuleAnn
    Typeable HsRuleAnn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HsRuleAnn -> c HsRuleAnn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HsRuleAnn)
    -> (HsRuleAnn -> Constr)
    -> (HsRuleAnn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HsRuleAnn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleAnn))
    -> ((forall b. Data b => b -> b) -> HsRuleAnn -> HsRuleAnn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HsRuleAnn -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> HsRuleAnn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn)
    -> Data HsRuleAnn
    HsRuleAnn -> Constr
    HsRuleAnn -> DataType
    (forall b. Data b => b -> b) -> HsRuleAnn -> HsRuleAnn
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> HsRuleAnn -> u
    forall u. (forall d. Data d => d -> u) -> HsRuleAnn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRuleAnn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRuleAnn -> c HsRuleAnn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRuleAnn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleAnn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRuleAnn -> c HsRuleAnn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HsRuleAnn -> c HsRuleAnn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRuleAnn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsRuleAnn
    $ctoConstr :: HsRuleAnn -> Constr
    toConstr :: HsRuleAnn -> Constr
    $cdataTypeOf :: HsRuleAnn -> DataType
    dataTypeOf :: HsRuleAnn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRuleAnn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsRuleAnn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleAnn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleAnn)
    $cgmapT :: (forall b. Data b => b -> b) -> HsRuleAnn -> HsRuleAnn
    gmapT :: (forall b. Data b => b -> b) -> HsRuleAnn -> HsRuleAnn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsRuleAnn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HsRuleAnn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRuleAnn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsRuleAnn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn
    Data, HsRuleAnn -> HsRuleAnn -> Bool
    (HsRuleAnn -> HsRuleAnn -> Bool)
    -> (HsRuleAnn -> HsRuleAnn -> Bool) -> Eq HsRuleAnn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HsRuleAnn -> HsRuleAnn -> Bool
    == :: HsRuleAnn -> HsRuleAnn -> Bool
    $c/= :: HsRuleAnn -> HsRuleAnn -> Bool
    /= :: HsRuleAnn -> HsRuleAnn -> Bool
    Eq)

    instance NoAnn HsRuleAnn where
      noAnn :: HsRuleAnn
    noAnn = Maybe (TokForall, EpToken ".")
    -> Maybe (TokForall, EpToken ".")
    -> EpToken "="
    -> ActivationAnn
    -> HsRuleAnn
    HsRuleAnn Maybe (TokForall, EpToken ".")
    forall a. Maybe a
    Nothing Maybe (TokForall, EpToken ".")
    forall a. Maybe a
    Nothing EpToken "="
    forall a. NoAnn a => a
    noAnn ActivationAnn
    forall a. NoAnn a => a
    noAnn

    flattenRuleDecls :: [LRuleDecls (GhcPass p)] -> [LRuleDecl (GhcPass p)]
    flattenRuleDecls :: forall (p :: Pass).
    [LRuleDecls (GhcPass p)] -> [LRuleDecl (GhcPass p)]
    flattenRuleDecls [LRuleDecls (GhcPass p)]
    decls = (GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))
     -> [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))])
    -> [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    -> [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap (RuleDecls (GhcPass p) -> [XRec (GhcPass p) (RuleDecl (GhcPass p))]
    RuleDecls (GhcPass p)
    -> [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))]
    forall pass. RuleDecls pass -> [LRuleDecl pass]
    rds_rules (RuleDecls (GhcPass p)
     -> [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))])
    -> (GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))
        -> RuleDecls (GhcPass p))
    -> GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))
    -> [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))
    -> RuleDecls (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc) [LRuleDecls (GhcPass p)]
    [GenLocated SrcSpanAnnA (RuleDecls (GhcPass p))]
    decls

    type instance XCRuleBndr    (GhcPass _) = AnnTyVarBndr
    type instance XRuleBndrSig  (GhcPass _) = AnnTyVarBndr
    type instance XXRuleBndr    (GhcPass _) = DataConCantHappen

    instance (OutputableBndrId p) => Outputable (RuleDecls (GhcPass p)) where
      ppr :: RuleDecls (GhcPass p) -> SDoc
    ppr (HsRules { rds_ext :: forall pass. RuleDecls pass -> XCRuleDecls pass
    rds_ext = XCRuleDecls (GhcPass p)
    ext
                   , rds_rules :: forall pass. RuleDecls pass -> [LRuleDecl pass]
    rds_rules = [LRuleDecl (GhcPass p)]
    rules })
        = SourceText -> SDoc -> SDoc
    pprWithSourceText SourceText
    st (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "{-# RULES")
              SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat (SDoc -> [SDoc] -> [SDoc]
    forall doc. IsLine doc => doc -> [doc] -> [doc]
    punctuate SDoc
    forall doc. IsLine doc => doc
    semi ((GenLocated SrcSpanAnnA (RuleDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (RuleDecl (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LRuleDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (RuleDecl (GhcPass p))]
    rules)) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "#-}"
                  where st :: SourceText
    st = case forall (p :: Pass). IsPass p => GhcPass p
    ghcPass @p of
                               GhcPass p
    GhcPs | ((EpaLocation, EpToken "#-}")
    _, SourceText
    st) <- XCRuleDecls (GhcPass p)
    ext -> SourceText
    st
                               GhcPass p
    GhcRn -> XCRuleDecls (GhcPass p)
    SourceText
    ext
                               GhcPass p
    GhcTc -> XCRuleDecls (GhcPass p)
    SourceText
    ext

    instance (OutputableBndrId p) => Outputable (RuleDecl (GhcPass p)) where
      ppr :: RuleDecl (GhcPass p) -> SDoc
    ppr (HsRule { rd_ext :: forall pass. RuleDecl pass -> XHsRule pass
    rd_ext  = XHsRule (GhcPass p)
    ext
                  , rd_name :: forall pass. RuleDecl pass -> XRec pass FastString
    rd_name = XRec (GhcPass p) FastString
    name
                  , rd_act :: forall pass. RuleDecl pass -> Activation
    rd_act  = Activation
    act
                  , rd_tyvs :: forall pass.
    RuleDecl pass -> Maybe [LHsTyVarBndr () (NoGhcTc pass)]
    rd_tyvs = Maybe [LHsTyVarBndr () (NoGhcTc (GhcPass p))]
    tys
                  , rd_tmvs :: forall pass. RuleDecl pass -> [LRuleBndr pass]
    rd_tmvs = [LRuleBndr (GhcPass p)]
    tms
                  , rd_lhs :: forall pass. RuleDecl pass -> XRec pass (HsExpr pass)
    rd_lhs  = XRec (GhcPass p) (HsExpr (GhcPass p))
    lhs
                  , rd_rhs :: forall pass. RuleDecl pass -> XRec pass (HsExpr pass)
    rd_rhs  = XRec (GhcPass p) (HsExpr (GhcPass p))
    rhs })
            = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [SourceText -> GenLocated (Anno FastString) FastString -> SDoc
    forall a. SourceText -> GenLocated a FastString -> SDoc
    pprFullRuleName SourceText
    st XRec (GhcPass p) FastString
    GenLocated (Anno FastString) FastString
    name SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Activation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Activation
    act,
                   Int -> SDoc -> SDoc
    nest Int
    4 (Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    -> SDoc
    forall {a}. Outputable a => Maybe [a] -> SDoc
    pp_forall_ty Maybe [LHsTyVarBndr () (NoGhcTc (GhcPass p))]
    Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    tys SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    -> SDoc
    pp_forall_tm Maybe [LHsTyVarBndr () (NoGhcTc (GhcPass p))]
    Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    tys
                                            SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> HsExpr (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsExpr (GhcPass p) -> SDoc
    pprExpr (GenLocated (Anno (HsExpr (GhcPass p))) (HsExpr (GhcPass p))
    -> HsExpr (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (HsExpr (GhcPass p))
    GenLocated (Anno (HsExpr (GhcPass p))) (HsExpr (GhcPass p))
    lhs)),
                   Int -> SDoc -> SDoc
    nest Int
    6 (SDoc
    forall doc. IsLine doc => doc
    equals SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> HsExpr (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsExpr (GhcPass p) -> SDoc
    pprExpr (GenLocated (Anno (HsExpr (GhcPass p))) (HsExpr (GhcPass p))
    -> HsExpr (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (HsExpr (GhcPass p))
    GenLocated (Anno (HsExpr (GhcPass p))) (HsExpr (GhcPass p))
    rhs)) ]
            where
              pp_forall_ty :: Maybe [a] -> SDoc
    pp_forall_ty Maybe [a]
    Nothing     = SDoc
    forall doc. IsOutput doc => doc
    empty
              pp_forall_ty (Just [a]
    qtvs) = SDoc
    forAllLit SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    fsep ((a -> SDoc) -> [a] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [a]
    qtvs) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    dot
              pp_forall_tm :: Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    -> SDoc
    pp_forall_tm Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    Nothing | [GenLocated EpAnnCO (RuleBndr (GhcPass p))] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LRuleBndr (GhcPass p)]
    [GenLocated EpAnnCO (RuleBndr (GhcPass p))]
    tms = SDoc
    forall doc. IsOutput doc => doc
    empty
              pp_forall_tm Maybe
      [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass (NoGhcTcPass p)))]
    _ = SDoc
    forAllLit SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    fsep ((GenLocated EpAnnCO (RuleBndr (GhcPass p)) -> SDoc)
    -> [GenLocated EpAnnCO (RuleBndr (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated EpAnnCO (RuleBndr (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LRuleBndr (GhcPass p)]
    [GenLocated EpAnnCO (RuleBndr (GhcPass p))]
    tms) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    dot
              st :: SourceText
    st = case forall (p :: Pass). IsPass p => GhcPass p
    ghcPass @p of
                     GhcPass p
    GhcPs | (HsRuleAnn
    _, SourceText
    st) <- XHsRule (GhcPass p)
    ext -> SourceText
    st
                     GhcPass p
    GhcRn | (HsRuleRn
    _, SourceText
    st) <- XHsRule (GhcPass p)
    ext -> SourceText
    st
                     GhcPass p
    GhcTc | (HsRuleRn
    _, SourceText
    st) <- XHsRule (GhcPass p)
    ext -> SourceText
    st

    instance (OutputableBndrId p) => Outputable (RuleBndr (GhcPass p)) where
       ppr :: RuleBndr (GhcPass p) -> SDoc
    ppr (RuleBndr XCRuleBndr (GhcPass p)
    _ LIdP (GhcPass p)
    name) = GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    name
       ppr (RuleBndrSig XRuleBndrSig (GhcPass p)
    _ LIdP (GhcPass p)
    name HsPatSigType (GhcPass p)
    ty) = SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    name SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> HsPatSigType (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsPatSigType (GhcPass p)
    ty)

    pprFullRuleName :: SourceText -> GenLocated a (RuleName) -> SDoc
    pprFullRuleName :: forall a. SourceText -> GenLocated a FastString -> SDoc
    pprFullRuleName SourceText
    st (L a
    _ FastString
    n) = SourceText -> SDoc -> SDoc
    pprWithSourceText SourceText
    st (SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    doubleQuotes (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ FastString -> SDoc
    forall doc. IsLine doc => FastString -> doc
    ftext FastString
    n)

    {-
    ************************************************************************
    *                                                                      *
    \subsection[DeprecDecl]{Deprecations}
    *                                                                      *
    ************************************************************************
    -}

    type instance XWarnings      GhcPs = ((EpaLocation, EpToken "#-}"), SourceText)
    type instance XWarnings      GhcRn = SourceText
    type instance XWarnings      GhcTc = SourceText

    type instance XXWarnDecls    (GhcPass _) = DataConCantHappen

    type instance XWarning      (GhcPass _) = (NamespaceSpecifier, (EpToken "[", EpToken "]"))
    type instance XXWarnDecl    (GhcPass _) = DataConCantHappen

    instance OutputableBndrId p
            => Outputable (WarnDecls (GhcPass p)) where
        ppr :: WarnDecls (GhcPass p) -> SDoc
    ppr (Warnings XWarnings (GhcPass p)
    ext [LWarnDecl (GhcPass p)]
    decls)
          = FastString -> SDoc
    forall doc. IsLine doc => FastString -> doc
    ftext FastString
    src SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat (SDoc -> [SDoc] -> [SDoc]
    forall doc. IsLine doc => doc -> [doc] -> [doc]
    punctuate SDoc
    forall doc. IsLine doc => doc
    semi ((GenLocated SrcSpanAnnA (WarnDecl (GhcPass p)) -> SDoc)
    -> [GenLocated SrcSpanAnnA (WarnDecl (GhcPass p))] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated SrcSpanAnnA (WarnDecl (GhcPass p)) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LWarnDecl (GhcPass p)]
    [GenLocated SrcSpanAnnA (WarnDecl (GhcPass p))]
    decls)) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "#-}"
          where src :: FastString
    src = case forall (p :: Pass). IsPass p => GhcPass p
    ghcPass @p of
                  GhcPass p
    GhcPs | ((EpaLocation, EpToken "#-}")
    _, SourceText FastString
    src) <- XWarnings (GhcPass p)
    ext -> FastString
    src
                  GhcPass p
    GhcRn | SourceText FastString
    src <- XWarnings (GhcPass p)
    ext -> FastString
    src
                  GhcPass p
    GhcTc | SourceText FastString
    src <- XWarnings (GhcPass p)
    ext -> FastString
    src
                  GhcPass p
    _ -> String -> FastString
    forall a. HasCallStack => String -> a
    panic String
    "WarnDecls"

    instance OutputableBndrId p
           => Outputable (WarnDecl (GhcPass p)) where
        ppr :: WarnDecl (GhcPass p) -> SDoc
    ppr (Warning (NamespaceSpecifier
    ns_spec, (EpToken "[", EpToken "]")
    _) [LIdP (GhcPass p)]
    thing WarningTxt (GhcPass p)
    txt)
          = SDoc
    ppr_category
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> NamespaceSpecifier -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr NamespaceSpecifier
    ns_spec
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep (SDoc -> [SDoc] -> [SDoc]
    forall doc. IsLine doc => doc -> [doc] -> [doc]
    punctuate SDoc
    forall doc. IsLine doc => doc
    comma ((GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc)
    -> [GenLocated (Anno (IdGhcP p)) (IdGhcP p)] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LIdP (GhcPass p)]
    [GenLocated (Anno (IdGhcP p)) (IdGhcP p)]
    thing))
                  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> WarningTxt (GhcPass p) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr WarningTxt (GhcPass p)
    txt
          where
            ppr_category :: SDoc
    ppr_category = case WarningTxt (GhcPass p)
    txt of
                             WarningTxt (Just LocatedE InWarningCategory
    cat) SourceText
    _ [LocatedE (WithHsDocIdentifiers StringLiteral (GhcPass p))]
    _ -> LocatedE InWarningCategory -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LocatedE InWarningCategory
    cat
                             WarningTxt (GhcPass p)
    _ -> SDoc
    forall doc. IsOutput doc => doc
    empty

    {-
    ************************************************************************
    *                                                                      *
    \subsection[AnnDecl]{Annotations}
    *                                                                      *
    ************************************************************************
    -}

    type instance XHsAnnotation (GhcPass _) = (AnnPragma, SourceText)
    type instance XXAnnDecl     (GhcPass _) = DataConCantHappen

    instance (OutputableBndrId p) => Outputable (AnnDecl (GhcPass p)) where
        ppr :: AnnDecl (GhcPass p) -> SDoc
    ppr (HsAnnotation XHsAnnotation (GhcPass p)
    _ AnnProvenance (GhcPass p)
    provenance XRec (GhcPass p) (HsExpr (GhcPass p))
    expr)
          = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep [String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "{-#", AnnProvenance (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    AnnProvenance (GhcPass p) -> SDoc
    pprAnnProvenance AnnProvenance (GhcPass p)
    provenance, HsExpr (GhcPass p) -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    HsExpr (GhcPass p) -> SDoc
    pprExpr (GenLocated (Anno (HsExpr (GhcPass p))) (HsExpr (GhcPass p))
    -> HsExpr (GhcPass p)
    forall l e. GenLocated l e -> e
    unLoc XRec (GhcPass p) (HsExpr (GhcPass p))
    GenLocated (Anno (HsExpr (GhcPass p))) (HsExpr (GhcPass p))
    expr), String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "#-}"]

    pprAnnProvenance :: OutputableBndrId p => AnnProvenance (GhcPass p) -> SDoc
    pprAnnProvenance :: forall (p :: Pass).
    OutputableBndrId p =>
    AnnProvenance (GhcPass p) -> SDoc
    pprAnnProvenance AnnProvenance (GhcPass p)
    ModuleAnnProvenance       = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ANN module"
    pprAnnProvenance (ValueAnnProvenance (L Anno (IdGhcP p)
    _ IdGhcP p
    name))
      = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ANN" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> IdGhcP p -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IdGhcP p
    name
    pprAnnProvenance (TypeAnnProvenance (L Anno (IdGhcP p)
    _ IdGhcP p
    name))
      = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ANN type" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> IdGhcP p -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr IdGhcP p
    name

    {-
    ************************************************************************
    *                                                                      *
    \subsection[RoleAnnot]{Role annotations}
    *                                                                      *
    ************************************************************************
    -}

    type instance XCRoleAnnotDecl GhcPs = (EpToken "type", EpToken "role")
    type instance XCRoleAnnotDecl GhcRn = NoExtField
    type instance XCRoleAnnotDecl GhcTc = NoExtField

    type instance XXRoleAnnotDecl (GhcPass _) = DataConCantHappen

    instance OutputableBndr (IdP (GhcPass p))
           => Outputable (RoleAnnotDecl (GhcPass p)) where
      ppr :: RoleAnnotDecl (GhcPass p) -> SDoc
    ppr (RoleAnnotDecl XCRoleAnnotDecl (GhcPass p)
    _ LIdP (GhcPass p)
    ltycon [XRec (GhcPass p) (Maybe Role)]
    roles)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "type role" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> IdGhcP p -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc (GenLocated (Anno (IdGhcP p)) (IdGhcP p) -> IdGhcP p
    forall l e. GenLocated l e -> e
    unLoc LIdP (GhcPass p)
    GenLocated (Anno (IdGhcP p)) (IdGhcP p)
    ltycon) SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+>
          [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hsep ((GenLocated EpAnnCO (Maybe Role) -> SDoc)
    -> [GenLocated EpAnnCO (Maybe Role)] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map (Maybe Role -> SDoc
    forall {a}. Outputable a => Maybe a -> SDoc
    pp_role (Maybe Role -> SDoc)
    -> (GenLocated EpAnnCO (Maybe Role) -> Maybe Role)
    -> GenLocated EpAnnCO (Maybe Role)
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated EpAnnCO (Maybe Role) -> Maybe Role
    forall l e. GenLocated l e -> e
    unLoc) [XRec (GhcPass p) (Maybe Role)]
    [GenLocated EpAnnCO (Maybe Role)]
    roles)
        where
          pp_role :: Maybe a -> SDoc
    pp_role Maybe a
    Nothing  = SDoc
    forall doc. IsLine doc => doc
    underscore
          pp_role (Just a
    r) = a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr a
    r

    roleAnnotDeclName :: RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
    roleAnnotDeclName :: forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
    roleAnnotDeclName (RoleAnnotDecl XCRoleAnnotDecl (GhcPass p)
    _ (L Anno (IdGhcP p)
    _ IdGhcP p
    name) [XRec (GhcPass p) (Maybe Role)]
    _) = IdP (GhcPass p)
    IdGhcP p
    name

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Anno instances}
    *                                                                      *
    ************************************************************************
    -}

    type instance Anno (HsDecl (GhcPass _)) = SrcSpanAnnA
    type instance Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (FunDep (GhcPass p)) = SrcSpanAnnA
    type instance Anno (FamilyResultSig (GhcPass p)) = EpAnnCO
    type instance Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (InjectivityAnn (GhcPass p)) = EpAnnCO
    type instance Anno CType = SrcSpanAnnP
    type instance Anno (HsDerivingClause (GhcPass p)) = EpAnnCO
    type instance Anno (DerivClauseTys (GhcPass _)) = SrcSpanAnnC
    type instance Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA
    type instance Anno (ConDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno Bool = EpAnnCO
    type instance Anno [LocatedA (ConDeclField (GhcPass _))] = SrcSpanAnnL
    type instance Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA
    type instance Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (FamEqn (GhcPass p) _) = SrcSpanAnnA
    type instance Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (InstDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (DocDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno OverlapMode = SrcSpanAnnP
    type instance Anno (DerivStrategy (GhcPass p)) = EpAnnCO
    type instance Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA
    type instance Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (SourceText, RuleName) = EpAnnCO
    type instance Anno (RuleBndr (GhcPass p)) = EpAnnCO
    type instance Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA
    type instance Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA
    type instance Anno (Maybe Role) = EpAnnCO
    type instance Anno CCallConv   = EpaLocation
    type instance Anno Safety      = EpaLocation
    type instance Anno CExportSpec = EpaLocation