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

    -- | Contains a debug function to dump parts of the GHC.Hs AST. It uses a syb
    -- traversal which falls back to displaying based on the constructor name, so
    -- can be used to dump anything having a @Data.Data@ instance.

    module GHC.Hs.Dump (
            -- * Dumping ASTs
            showAstData,
            BlankSrcSpan(..),
            BlankEpAnnotations(..),
        ) where

    import GHC.Prelude

    import GHC.Hs

    import GHC.Core.DataCon

    import GHC.Data.Bag
    import GHC.Data.FastString
    import GHC.Types.Name.Set
    import GHC.Types.Name
    import GHC.Types.SrcLoc
    import GHC.Types.Var
    import GHC.Types.SourceText
    import GHC.Unit.Module
    import GHC.Utils.Outputable

    import Data.Data hiding (Fixity)
    import qualified Data.ByteString as B

    data BlankSrcSpan = BlankSrcSpan | BlankSrcSpanFile | NoBlankSrcSpan
                      deriving (BlankSrcSpan -> BlankSrcSpan -> Bool
    (BlankSrcSpan -> BlankSrcSpan -> Bool)
    -> (BlankSrcSpan -> BlankSrcSpan -> Bool) -> Eq BlankSrcSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BlankSrcSpan -> BlankSrcSpan -> Bool
    $c/= :: BlankSrcSpan -> BlankSrcSpan -> Bool
    == :: BlankSrcSpan -> BlankSrcSpan -> Bool
    $c== :: BlankSrcSpan -> BlankSrcSpan -> Bool
    Eq,Int -> BlankSrcSpan -> ShowS
    [BlankSrcSpan] -> ShowS
    BlankSrcSpan -> String
    (Int -> BlankSrcSpan -> ShowS)
    -> (BlankSrcSpan -> String)
    -> ([BlankSrcSpan] -> ShowS)
    -> Show BlankSrcSpan
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [BlankSrcSpan] -> ShowS
    $cshowList :: [BlankSrcSpan] -> ShowS
    show :: BlankSrcSpan -> String
    $cshow :: BlankSrcSpan -> String
    showsPrec :: Int -> BlankSrcSpan -> ShowS
    $cshowsPrec :: Int -> BlankSrcSpan -> ShowS
    Show)

    data BlankEpAnnotations = BlankEpAnnotations | NoBlankEpAnnotations
                      deriving (BlankEpAnnotations -> BlankEpAnnotations -> Bool
    (BlankEpAnnotations -> BlankEpAnnotations -> Bool)
    -> (BlankEpAnnotations -> BlankEpAnnotations -> Bool)
    -> Eq BlankEpAnnotations
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BlankEpAnnotations -> BlankEpAnnotations -> Bool
    $c/= :: BlankEpAnnotations -> BlankEpAnnotations -> Bool
    == :: BlankEpAnnotations -> BlankEpAnnotations -> Bool
    $c== :: BlankEpAnnotations -> BlankEpAnnotations -> Bool
    Eq,Int -> BlankEpAnnotations -> ShowS
    [BlankEpAnnotations] -> ShowS
    BlankEpAnnotations -> String
    (Int -> BlankEpAnnotations -> ShowS)
    -> (BlankEpAnnotations -> String)
    -> ([BlankEpAnnotations] -> ShowS)
    -> Show BlankEpAnnotations
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [BlankEpAnnotations] -> ShowS
    $cshowList :: [BlankEpAnnotations] -> ShowS
    show :: BlankEpAnnotations -> String
    $cshow :: BlankEpAnnotations -> String
    showsPrec :: Int -> BlankEpAnnotations -> ShowS
    $cshowsPrec :: Int -> BlankEpAnnotations -> ShowS
    Show)

    -- | Show a GHC syntax tree. This parameterised because it is also used for
    -- comparing ASTs in ppr roundtripping tests, where the SrcSpan's are blanked
    -- out, to avoid comparing locations, only structure
    showAstData :: Data a => BlankSrcSpan -> BlankEpAnnotations -> a -> SDoc
    showAstData :: forall a. Data a => BlankSrcSpan -> BlankEpAnnotations -> a -> SDoc
    showAstData BlankSrcSpan
    bs BlankEpAnnotations
    ba a
    a0 = SDoc
    blankLine SDoc -> SDoc -> SDoc
    $$ a -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' a
    a0
      where
        showAstData' :: Data a => a -> SDoc
        showAstData' :: forall a. Data a => a -> SDoc
    showAstData' =
          a -> SDoc
    forall a. Data a => a -> SDoc
    generic
                  (a -> SDoc) -> (forall e. Data e => [e] -> SDoc) -> a -> SDoc
    forall d (t :: * -> *) q.
    (Data d, Typeable t) =>
    (d -> q) -> (forall e. Data e => t e -> q) -> d -> q
    `ext1Q` forall e. Data e => [e] -> SDoc
    list
                  (a -> SDoc) -> (String -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` String -> SDoc
    string (a -> SDoc) -> (FastString -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` FastString -> SDoc
    fastString (a -> SDoc) -> (SrcSpan -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SrcSpan -> SDoc
    srcSpan (a -> SDoc) -> (RealSrcSpan -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` RealSrcSpan -> SDoc
    realSrcSpan
                  (a -> SDoc) -> (EpAnn [AddEpAnn] -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn [AddEpAnn] -> SDoc
    annotation
                  (a -> SDoc) -> (EpAnn AnnsModule -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn AnnsModule -> SDoc
    annotationModule
                  (a -> SDoc) -> (EpAnn AddEpAnn -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn AddEpAnn -> SDoc
    annotationAddEpAnn
                  (a -> SDoc) -> (EpAnn GrhsAnn -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn GrhsAnn -> SDoc
    annotationGrhsAnn
                  (a -> SDoc) -> (EpAnn EpAnnHsCase -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn EpAnnHsCase -> SDoc
    annotationEpAnnHsCase
                  (a -> SDoc) -> (EpAnn AnnsLet -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn AnnsLet -> SDoc
    annotationEpAnnHsLet
                  (a -> SDoc) -> (EpAnn AnnList -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn AnnList -> SDoc
    annotationAnnList
                  (a -> SDoc) -> (EpAnn EpAnnImportDecl -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn EpAnnImportDecl -> SDoc
    annotationEpAnnImportDecl
                  (a -> SDoc) -> (EpAnn AnnParen -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn AnnParen -> SDoc
    annotationAnnParen
                  (a -> SDoc) -> (EpAnn TrailingAnn -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpAnn TrailingAnn -> SDoc
    annotationTrailingAnn
                  (a -> SDoc) -> (AddEpAnn -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` AddEpAnn -> SDoc
    addEpAnn
                  (a -> SDoc) -> (HsLit GhcPs -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` HsLit GhcPs -> SDoc
    lit (a -> SDoc) -> (HsLit GhcRn -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` HsLit GhcRn -> SDoc
    litr (a -> SDoc) -> (HsLit GhcTc -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` HsLit GhcTc -> SDoc
    litt
                  (a -> SDoc) -> (SourceText -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SourceText -> SDoc
    sourceText
                  (a -> SDoc) -> (DeltaPos -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` DeltaPos -> SDoc
    deltaPos
                  (a -> SDoc) -> (EpaLocation -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` EpaLocation -> SDoc
    epaAnchor
                  (a -> SDoc) -> (ByteString -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` ByteString -> SDoc
    bytestring
                  (a -> SDoc) -> (Name -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` Name -> SDoc
    name (a -> SDoc) -> (OccName -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` OccName -> SDoc
    occName (a -> SDoc) -> (ModuleName -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` ModuleName -> SDoc
    moduleName (a -> SDoc) -> (Var -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` Var -> SDoc
    var
                  (a -> SDoc) -> (DataCon -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` DataCon -> SDoc
    dataCon
                  (a -> SDoc) -> (Bag (LocatedA (HsBind GhcRn)) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` Bag (LocatedA (HsBind GhcRn)) -> SDoc
    bagName (a -> SDoc) -> (Bag (LocatedA (HsBind GhcPs)) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` Bag (LocatedA (HsBind GhcPs)) -> SDoc
    bagRdrName (a -> SDoc) -> (Bag (LocatedA (HsBind GhcTc)) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` Bag (LocatedA (HsBind GhcTc)) -> SDoc
    bagVar (a -> SDoc) -> (NameSet -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` NameSet -> SDoc
    nameSet
                  (a -> SDoc) -> (Fixity -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` Fixity -> SDoc
    fixity
                  (a -> SDoc)
    -> (forall d1 d2. (Data d1, Data d2) => GenLocated d1 d2 -> SDoc)
    -> a
    -> SDoc
    forall d (t :: * -> * -> *) q.
    (Data d, Typeable t) =>
    (d -> q)
    -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) -> d -> q
    `ext2Q` forall d1 d2. (Data d1, Data d2) => GenLocated d1 d2 -> SDoc
    located
                  (a -> SDoc)
    -> (SrcSpanAnn' (EpAnn AnnListItem) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SrcSpanAnn' (EpAnn AnnListItem) -> SDoc
    srcSpanAnnA
                  (a -> SDoc) -> (SrcSpanAnn' (EpAnn AnnList) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SrcSpanAnn' (EpAnn AnnList) -> SDoc
    srcSpanAnnL
                  (a -> SDoc) -> (SrcSpanAnn' (EpAnn AnnPragma) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SrcSpanAnn' (EpAnn AnnPragma) -> SDoc
    srcSpanAnnP
                  (a -> SDoc)
    -> (SrcSpanAnn' (EpAnn AnnContext) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SrcSpanAnn' (EpAnn AnnContext) -> SDoc
    srcSpanAnnC
                  (a -> SDoc) -> (SrcSpanAnn' (EpAnn NameAnn) -> SDoc) -> a -> SDoc
    forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    `extQ` SrcSpanAnn' (EpAnn NameAnn) -> SDoc
    srcSpanAnnN

          where generic :: Data a => a -> SDoc
                generic :: forall a. Data a => a -> SDoc
    generic a
    t = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text (Constr -> String
    showConstr (a -> Constr
    forall a. Data a => a -> Constr
    toConstr a
    t))
                                      SDoc -> SDoc -> SDoc
    $$ [SDoc] -> SDoc
    vcat ((forall a. Data a => a -> SDoc) -> a -> [SDoc]
    forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
    gmapQ forall a. Data a => a -> SDoc
    showAstData' a
    t)

                string :: String -> SDoc
                string :: String -> SDoc
    string     = String -> SDoc
    text (String -> SDoc) -> ShowS -> String -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShowS
    normalize_newlines ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShowS
    forall a. Show a => a -> String
    show

                fastString :: FastString -> SDoc
                fastString :: FastString -> SDoc
    fastString FastString
    s = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                                String -> SDoc
    text String
    "FastString:"
                            SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text (ShowS
    normalize_newlines ShowS -> (FastString -> String) -> FastString -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FastString -> String
    forall a. Show a => a -> String
    show (FastString -> String) -> FastString -> String
    forall a b. (a -> b) -> a -> b
    $ FastString
    s)

                bytestring :: B.ByteString -> SDoc
                bytestring :: ByteString -> SDoc
    bytestring = String -> SDoc
    text (String -> SDoc) -> (ByteString -> String) -> ByteString -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ShowS
    normalize_newlines ShowS -> (ByteString -> String) -> ByteString -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> String
    forall a. Show a => a -> String
    show

                list :: [t] -> SDoc
    list []    = SDoc -> SDoc
    brackets SDoc
    empty
                list [t
    x]   = SDoc -> SDoc
    brackets (t -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' t
    x)
                list (t
    x1 : t
    x2 : [t]
    xs) =  (String -> SDoc
    text String
    "[" SDoc -> SDoc -> SDoc
    <> t -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' t
    x1)
                                    SDoc -> SDoc -> SDoc
    $$ t -> [t] -> SDoc
    forall {t}. Data t => t -> [t] -> SDoc
    go t
    x2 [t]
    xs
                  where
                    go :: t -> [t] -> SDoc
    go t
    y [] = String -> SDoc
    text String
    "," SDoc -> SDoc -> SDoc
    <> t -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' t
    y SDoc -> SDoc -> SDoc
    <> String -> SDoc
    text String
    "]"
                    go t
    y1 (t
    y2 : [t]
    ys) = (String -> SDoc
    text String
    "," SDoc -> SDoc -> SDoc
    <> t -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' t
    y1) SDoc -> SDoc -> SDoc
    $$ t -> [t] -> SDoc
    go t
    y2 [t]
    ys

                -- Eliminate word-size dependence
                lit :: HsLit GhcPs -> SDoc
                lit :: HsLit GhcPs -> SDoc
    lit (HsWordPrim   XHsWordPrim GhcPs
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsWord{64}Prim" Integer
    x SourceText
    XHsWordPrim GhcPs
    s
                lit (HsWord64Prim XHsWord64Prim GhcPs
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsWord{64}Prim" Integer
    x SourceText
    XHsWord64Prim GhcPs
    s
                lit (HsIntPrim    XHsIntPrim GhcPs
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsInt{64}Prim"  Integer
    x SourceText
    XHsIntPrim GhcPs
    s
                lit (HsInt64Prim  XHsInt64Prim GhcPs
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsInt{64}Prim"  Integer
    x SourceText
    XHsInt64Prim GhcPs
    s
                lit HsLit GhcPs
    l                  = HsLit GhcPs -> SDoc
    forall a. Data a => a -> SDoc
    generic HsLit GhcPs
    l

                litr :: HsLit GhcRn -> SDoc
                litr :: HsLit GhcRn -> SDoc
    litr (HsWordPrim   XHsWordPrim GhcRn
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsWord{64}Prim" Integer
    x SourceText
    XHsWordPrim GhcRn
    s
                litr (HsWord64Prim XHsWord64Prim GhcRn
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsWord{64}Prim" Integer
    x SourceText
    XHsWord64Prim GhcRn
    s
                litr (HsIntPrim    XHsIntPrim GhcRn
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsInt{64}Prim"  Integer
    x SourceText
    XHsIntPrim GhcRn
    s
                litr (HsInt64Prim  XHsInt64Prim GhcRn
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsInt{64}Prim"  Integer
    x SourceText
    XHsInt64Prim GhcRn
    s
                litr HsLit GhcRn
    l                  = HsLit GhcRn -> SDoc
    forall a. Data a => a -> SDoc
    generic HsLit GhcRn
    l

                litt :: HsLit GhcTc -> SDoc
                litt :: HsLit GhcTc -> SDoc
    litt (HsWordPrim   XHsWordPrim GhcTc
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsWord{64}Prim" Integer
    x SourceText
    XHsWordPrim GhcTc
    s
                litt (HsWord64Prim XHsWord64Prim GhcTc
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsWord{64}Prim" Integer
    x SourceText
    XHsWord64Prim GhcTc
    s
                litt (HsIntPrim    XHsIntPrim GhcTc
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsInt{64}Prim"  Integer
    x SourceText
    XHsIntPrim GhcTc
    s
                litt (HsInt64Prim  XHsInt64Prim GhcTc
    s Integer
    x) = String -> Integer -> SourceText -> SDoc
    numericLit String
    "HsInt{64}Prim"  Integer
    x SourceText
    XHsInt64Prim GhcTc
    s
                litt HsLit GhcTc
    l                  = HsLit GhcTc -> SDoc
    forall a. Data a => a -> SDoc
    generic HsLit GhcTc
    l

                numericLit :: String -> Integer -> SourceText -> SDoc
                numericLit :: String -> Integer -> SourceText -> SDoc
    numericLit String
    tag Integer
    x SourceText
    s = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ [SDoc] -> SDoc
    hsep [ String -> SDoc
    text String
    tag
                                                   , Integer -> SDoc
    forall a. Data a => a -> SDoc
    generic Integer
    x
                                                   , SourceText -> SDoc
    forall a. Data a => a -> SDoc
    generic SourceText
    s ]

                sourceText :: SourceText -> SDoc
                sourceText :: SourceText -> SDoc
    sourceText SourceText
    NoSourceText = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "NoSourceText"
                sourceText (SourceText String
    src) = case BlankSrcSpan
    bs of
                  BlankSrcSpan
    NoBlankSrcSpan   -> SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "SourceText" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    src
                  BlankSrcSpan
    BlankSrcSpanFile -> SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "SourceText" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    src
                  BlankSrcSpan
    _                -> SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "SourceText" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "blanked"

                epaAnchor :: EpaLocation -> SDoc
                epaAnchor :: EpaLocation -> SDoc
    epaAnchor (EpaSpan RealSrcSpan
    r)  = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "EpaSpan" SDoc -> SDoc -> SDoc
    <+> RealSrcSpan -> SDoc
    realSrcSpan RealSrcSpan
    r
                epaAnchor (EpaDelta DeltaPos
    d) = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "EpaDelta" SDoc -> SDoc -> SDoc
    <+> DeltaPos -> SDoc
    deltaPos DeltaPos
    d

                deltaPos :: DeltaPos -> SDoc
                deltaPos :: DeltaPos -> SDoc
    deltaPos (SameLine Int
    c) = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "SameLine" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    c
                deltaPos (DifferentLine Int
    l Int
    c) = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "DifferentLine" SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    l SDoc -> SDoc -> SDoc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    c

                name :: Name -> SDoc
                name :: Name -> SDoc
    name Name
    nm    = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "Name:" SDoc -> SDoc -> SDoc
    <+> Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    nm

                occName :: OccName -> SDoc
    occName OccName
    n  =  SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                              String -> SDoc
    text String
    "OccName:"
                          SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text (OccName -> String
    occNameString OccName
    n)

                moduleName :: ModuleName -> SDoc
                moduleName :: ModuleName -> SDoc
    moduleName ModuleName
    m = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "ModuleName:" SDoc -> SDoc -> SDoc
    <+> ModuleName -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr ModuleName
    m

                srcSpan :: SrcSpan -> SDoc
                srcSpan :: SrcSpan -> SDoc
    srcSpan SrcSpan
    ss = case BlankSrcSpan
    bs of
                 BlankSrcSpan
    BlankSrcSpan -> String -> SDoc
    text String
    "{ ss }"
                 BlankSrcSpan
    NoBlankSrcSpan -> SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Char -> SDoc
    char Char
    ' ' SDoc -> SDoc -> SDoc
    <>
                                 (SDoc -> Int -> SDoc -> SDoc
    hang (SrcSpan -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr SrcSpan
    ss) Int
    1
                                       -- TODO: show annotations here
                                       (String -> SDoc
    text String
    ""))
                 BlankSrcSpan
    BlankSrcSpanFile -> SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Char -> SDoc
    char Char
    ' ' SDoc -> SDoc -> SDoc
    <>
                                 (SDoc -> Int -> SDoc -> SDoc
    hang (Bool -> SrcSpan -> SDoc
    pprUserSpan Bool
    False SrcSpan
    ss) Int
    1
                                       -- TODO: show annotations here
                                       (String -> SDoc
    text String
    ""))

                realSrcSpan :: RealSrcSpan -> SDoc
                realSrcSpan :: RealSrcSpan -> SDoc
    realSrcSpan RealSrcSpan
    ss = case BlankSrcSpan
    bs of
                 BlankSrcSpan
    BlankSrcSpan -> String -> SDoc
    text String
    "{ ss }"
                 BlankSrcSpan
    NoBlankSrcSpan -> SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Char -> SDoc
    char Char
    ' ' SDoc -> SDoc -> SDoc
    <>
                                 (SDoc -> Int -> SDoc -> SDoc
    hang (RealSrcSpan -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RealSrcSpan
    ss) Int
    1
                                       -- TODO: show annotations here
                                       (String -> SDoc
    text String
    ""))
                 BlankSrcSpan
    BlankSrcSpanFile -> SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Char -> SDoc
    char Char
    ' ' SDoc -> SDoc -> SDoc
    <>
                                 (SDoc -> Int -> SDoc -> SDoc
    hang (Bool -> RealSrcSpan -> SDoc
    pprUserRealSpan Bool
    False RealSrcSpan
    ss) Int
    1
                                       -- TODO: show annotations here
                                       (String -> SDoc
    text String
    ""))

                addEpAnn :: AddEpAnn -> SDoc
                addEpAnn :: AddEpAnn -> SDoc
    addEpAnn (AddEpAnn AnnKeywordId
    a EpaLocation
    s) = case BlankEpAnnotations
    ba of
                 BlankEpAnnotations
    BlankEpAnnotations -> SDoc -> SDoc
    parens
                                          (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "blanked:" SDoc -> SDoc -> SDoc
    <+> String -> SDoc
    text String
    "AddEpAnn"
                 BlankEpAnnotations
    NoBlankEpAnnotations ->
                  SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "AddEpAnn" SDoc -> SDoc -> SDoc
    <+> AnnKeywordId -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr AnnKeywordId
    a SDoc -> SDoc -> SDoc
    <+> EpaLocation -> SDoc
    epaAnchor EpaLocation
    s

                var  :: Var -> SDoc
                var :: Var -> SDoc
    var Var
    v      = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "Var:" SDoc -> SDoc -> SDoc
    <+> Var -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Var
    v

                dataCon :: DataCon -> SDoc
                dataCon :: DataCon -> SDoc
    dataCon DataCon
    c  = SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text String
    "DataCon:" SDoc -> SDoc -> SDoc
    <+> DataCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DataCon
    c

                bagRdrName:: Bag (LocatedA (HsBind GhcPs)) -> SDoc
                bagRdrName :: Bag (LocatedA (HsBind GhcPs)) -> SDoc
    bagRdrName Bag (LocatedA (HsBind GhcPs))
    bg =  SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                                 String -> SDoc
    text String
    "Bag(LocatedA (HsBind GhcPs)):"
                              SDoc -> SDoc -> SDoc
    $$ ([LocatedA (HsBind GhcPs)] -> SDoc
    forall e. Data e => [e] -> SDoc
    list ([LocatedA (HsBind GhcPs)] -> SDoc)
    -> (Bag (LocatedA (HsBind GhcPs)) -> [LocatedA (HsBind GhcPs)])
    -> Bag (LocatedA (HsBind GhcPs))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bag (LocatedA (HsBind GhcPs)) -> [LocatedA (HsBind GhcPs)]
    forall a. Bag a -> [a]
    bagToList (Bag (LocatedA (HsBind GhcPs)) -> SDoc)
    -> Bag (LocatedA (HsBind GhcPs)) -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Bag (LocatedA (HsBind GhcPs))
    bg)

                bagName   :: Bag (LocatedA (HsBind GhcRn)) -> SDoc
                bagName :: Bag (LocatedA (HsBind GhcRn)) -> SDoc
    bagName Bag (LocatedA (HsBind GhcRn))
    bg  =  SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                               String -> SDoc
    text String
    "Bag(LocatedA (HsBind Name)):"
                            SDoc -> SDoc -> SDoc
    $$ ([LocatedA (HsBind GhcRn)] -> SDoc
    forall e. Data e => [e] -> SDoc
    list ([LocatedA (HsBind GhcRn)] -> SDoc)
    -> (Bag (LocatedA (HsBind GhcRn)) -> [LocatedA (HsBind GhcRn)])
    -> Bag (LocatedA (HsBind GhcRn))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bag (LocatedA (HsBind GhcRn)) -> [LocatedA (HsBind GhcRn)]
    forall a. Bag a -> [a]
    bagToList (Bag (LocatedA (HsBind GhcRn)) -> SDoc)
    -> Bag (LocatedA (HsBind GhcRn)) -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Bag (LocatedA (HsBind GhcRn))
    bg)

                bagVar    :: Bag (LocatedA (HsBind GhcTc)) -> SDoc
                bagVar :: Bag (LocatedA (HsBind GhcTc)) -> SDoc
    bagVar Bag (LocatedA (HsBind GhcTc))
    bg  =  SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                              String -> SDoc
    text String
    "Bag(LocatedA (HsBind Var)):"
                           SDoc -> SDoc -> SDoc
    $$ ([LocatedA (HsBind GhcTc)] -> SDoc
    forall e. Data e => [e] -> SDoc
    list ([LocatedA (HsBind GhcTc)] -> SDoc)
    -> (Bag (LocatedA (HsBind GhcTc)) -> [LocatedA (HsBind GhcTc)])
    -> Bag (LocatedA (HsBind GhcTc))
    -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bag (LocatedA (HsBind GhcTc)) -> [LocatedA (HsBind GhcTc)]
    forall a. Bag a -> [a]
    bagToList (Bag (LocatedA (HsBind GhcTc)) -> SDoc)
    -> Bag (LocatedA (HsBind GhcTc)) -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Bag (LocatedA (HsBind GhcTc))
    bg)

                nameSet :: NameSet -> SDoc
    nameSet NameSet
    ns =  SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                              String -> SDoc
    text String
    "NameSet:"
                           SDoc -> SDoc -> SDoc
    $$ ([Name] -> SDoc
    forall e. Data e => [e] -> SDoc
    list ([Name] -> SDoc) -> (NameSet -> [Name]) -> NameSet -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NameSet -> [Name]
    nameSetElemsStable (NameSet -> SDoc) -> NameSet -> SDoc
    forall a b. (a -> b) -> a -> b
    $ NameSet
    ns)

                fixity :: Fixity -> SDoc
                fixity :: Fixity -> SDoc
    fixity Fixity
    fx =  SDoc -> SDoc
    braces (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                             String -> SDoc
    text String
    "Fixity:"
                         SDoc -> SDoc -> SDoc
    <+> Fixity -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Fixity
    fx

                located :: (Data a, Data b) => GenLocated a b -> SDoc
                located :: forall d1 d2. (Data d1, Data d2) => GenLocated d1 d2 -> SDoc
    located (L a
    ss b
    a)
                  = SDoc -> SDoc
    parens (String -> SDoc
    text String
    "L"
                            SDoc -> SDoc -> SDoc
    $$ [SDoc] -> SDoc
    vcat [a -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' a
    ss, b -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' b
    a])

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

                annotation :: EpAnn [AddEpAnn] -> SDoc
                annotation :: EpAnn [AddEpAnn] -> SDoc
    annotation = SDoc -> EpAnn [AddEpAnn] -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn [AddEpAnn]")

                annotationModule :: EpAnn AnnsModule -> SDoc
                annotationModule :: EpAnn AnnsModule -> SDoc
    annotationModule = SDoc -> EpAnn AnnsModule -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn AnnsModule")

                annotationAddEpAnn :: EpAnn AddEpAnn -> SDoc
                annotationAddEpAnn :: EpAnn AddEpAnn -> SDoc
    annotationAddEpAnn = SDoc -> EpAnn AddEpAnn -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn AddEpAnn")

                annotationGrhsAnn :: EpAnn GrhsAnn -> SDoc
                annotationGrhsAnn :: EpAnn GrhsAnn -> SDoc
    annotationGrhsAnn = SDoc -> EpAnn GrhsAnn -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn GrhsAnn")

                annotationEpAnnHsCase :: EpAnn EpAnnHsCase -> SDoc
                annotationEpAnnHsCase :: EpAnn EpAnnHsCase -> SDoc
    annotationEpAnnHsCase = SDoc -> EpAnn EpAnnHsCase -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn EpAnnHsCase")

                annotationEpAnnHsLet :: EpAnn AnnsLet -> SDoc
                annotationEpAnnHsLet :: EpAnn AnnsLet -> SDoc
    annotationEpAnnHsLet = SDoc -> EpAnn AnnsLet -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn AnnsLet")

                annotationAnnList :: EpAnn AnnList -> SDoc
                annotationAnnList :: EpAnn AnnList -> SDoc
    annotationAnnList = SDoc -> EpAnn AnnList -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn AnnList")

                annotationEpAnnImportDecl :: EpAnn EpAnnImportDecl -> SDoc
                annotationEpAnnImportDecl :: EpAnn EpAnnImportDecl -> SDoc
    annotationEpAnnImportDecl = SDoc -> EpAnn EpAnnImportDecl -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn EpAnnImportDecl")

                annotationAnnParen :: EpAnn AnnParen -> SDoc
                annotationAnnParen :: EpAnn AnnParen -> SDoc
    annotationAnnParen = SDoc -> EpAnn AnnParen -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn AnnParen")

                annotationTrailingAnn :: EpAnn TrailingAnn -> SDoc
                annotationTrailingAnn :: EpAnn TrailingAnn -> SDoc
    annotationTrailingAnn = SDoc -> EpAnn TrailingAnn -> SDoc
    forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' (String -> SDoc
    text String
    "EpAnn TrailingAnn")

                annotation' :: forall a .(Data a, Typeable a)
                           => SDoc -> EpAnn a -> SDoc
                annotation' :: forall a. (Data a, Typeable a) => SDoc -> EpAnn a -> SDoc
    annotation' SDoc
    tag EpAnn a
    anns = case BlankEpAnnotations
    ba of
                 BlankEpAnnotations
    BlankEpAnnotations -> SDoc -> SDoc
    parens (String -> SDoc
    text String
    "blanked:" SDoc -> SDoc -> SDoc
    <+> SDoc
    tag)
                 BlankEpAnnotations
    NoBlankEpAnnotations -> SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text (Constr -> String
    showConstr (EpAnn a -> Constr
    forall a. Data a => a -> Constr
    toConstr EpAnn a
    anns))
                                                   SDoc -> SDoc -> SDoc
    $$ [SDoc] -> SDoc
    vcat ((forall a. Data a => a -> SDoc) -> EpAnn a -> [SDoc]
    forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
    gmapQ forall a. Data a => a -> SDoc
    showAstData' EpAnn a
    anns)

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

                srcSpanAnnA :: SrcSpanAnn' (EpAnn AnnListItem) -> SDoc
                srcSpanAnnA :: SrcSpanAnn' (EpAnn AnnListItem) -> SDoc
    srcSpanAnnA = SDoc -> SrcSpanAnn' (EpAnn AnnListItem) -> SDoc
    forall a. (Typeable a, Data a) => SDoc -> SrcSpanAnn' a -> SDoc
    locatedAnn'' (String -> SDoc
    text String
    "SrcSpanAnnA")

                srcSpanAnnL :: SrcSpanAnn' (EpAnn AnnList) -> SDoc
                srcSpanAnnL :: SrcSpanAnn' (EpAnn AnnList) -> SDoc
    srcSpanAnnL = SDoc -> SrcSpanAnn' (EpAnn AnnList) -> SDoc
    forall a. (Typeable a, Data a) => SDoc -> SrcSpanAnn' a -> SDoc
    locatedAnn'' (String -> SDoc
    text String
    "SrcSpanAnnL")

                srcSpanAnnP :: SrcSpanAnn' (EpAnn AnnPragma) -> SDoc
                srcSpanAnnP :: SrcSpanAnn' (EpAnn AnnPragma) -> SDoc
    srcSpanAnnP = SDoc -> SrcSpanAnn' (EpAnn AnnPragma) -> SDoc
    forall a. (Typeable a, Data a) => SDoc -> SrcSpanAnn' a -> SDoc
    locatedAnn'' (String -> SDoc
    text String
    "SrcSpanAnnP")

                srcSpanAnnC :: SrcSpanAnn' (EpAnn AnnContext) -> SDoc
                srcSpanAnnC :: SrcSpanAnn' (EpAnn AnnContext) -> SDoc
    srcSpanAnnC = SDoc -> SrcSpanAnn' (EpAnn AnnContext) -> SDoc
    forall a. (Typeable a, Data a) => SDoc -> SrcSpanAnn' a -> SDoc
    locatedAnn'' (String -> SDoc
    text String
    "SrcSpanAnnC")

                srcSpanAnnN :: SrcSpanAnn' (EpAnn NameAnn) -> SDoc
                srcSpanAnnN :: SrcSpanAnn' (EpAnn NameAnn) -> SDoc
    srcSpanAnnN = SDoc -> SrcSpanAnn' (EpAnn NameAnn) -> SDoc
    forall a. (Typeable a, Data a) => SDoc -> SrcSpanAnn' a -> SDoc
    locatedAnn'' (String -> SDoc
    text String
    "SrcSpanAnnN")

                locatedAnn'' :: forall a. (Typeable a, Data a)
                  => SDoc -> SrcSpanAnn' a -> SDoc
                locatedAnn'' :: forall a. (Typeable a, Data a) => SDoc -> SrcSpanAnn' a -> SDoc
    locatedAnn'' SDoc
    tag SrcSpanAnn' a
    ss = SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $
                  case SrcSpanAnn' a -> Maybe (SrcSpanAnn' a)
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast SrcSpanAnn' a
    ss of
                    Just ((SrcSpanAnn a
    ann SrcSpan
    s) :: SrcSpanAnn' a) ->
                      case BlankEpAnnotations
    ba of
                        BlankEpAnnotations
    BlankEpAnnotations
                          -> SDoc -> SDoc
    parens (String -> SDoc
    text String
    "blanked:" SDoc -> SDoc -> SDoc
    <+> SDoc
    tag)
                        BlankEpAnnotations
    NoBlankEpAnnotations
                          -> String -> SDoc
    text String
    "SrcSpanAnn" SDoc -> SDoc -> SDoc
    <+> a -> SDoc
    forall a. Data a => a -> SDoc
    showAstData' a
    ann
                                  SDoc -> SDoc -> SDoc
    <+> SrcSpan -> SDoc
    srcSpan SrcSpan
    s
                    Maybe (SrcSpanAnn' a)
    Nothing -> String -> SDoc
    text String
    "locatedAnn:unmatched" SDoc -> SDoc -> SDoc
    <+> SDoc
    tag
                               SDoc -> SDoc -> SDoc
    <+> (SDoc -> SDoc
    parens (SDoc -> SDoc) -> SDoc -> SDoc
    forall a b. (a -> b) -> a -> b
    $ String -> SDoc
    text (Constr -> String
    showConstr (SrcSpanAnn' a -> Constr
    forall a. Data a => a -> Constr
    toConstr SrcSpanAnn' a
    ss)))

    normalize_newlines :: String -> String
    normalize_newlines :: ShowS
    normalize_newlines (Char
    '\\':Char
    'r':Char
    '\\':Char
    'n':String
    xs) = Char
    '\\'Char -> ShowS
    forall a. a -> [a] -> [a]
    :Char
    'n'Char -> ShowS
    forall a. a -> [a] -> [a]
    :ShowS
    normalize_newlines String
    xs
    normalize_newlines (Char
    x:String
    xs)                 = Char
    xChar -> ShowS
    forall a. a -> [a] -> [a]
    :ShowS
    normalize_newlines String
    xs
    normalize_newlines []                     = []

    {-
    ************************************************************************
    *                                                                      *
    * Copied from syb
    *                                                                      *
    ************************************************************************
    -}

    -- | The type constructor for queries
    newtype Q q x = Q { forall q x. Q q x -> x -> q
    unQ :: x -> q }

    -- | Extend a generic query by a type-specific case
    extQ :: ( Typeable a
            , Typeable b
            )
         => (a -> q)
         -> (b -> q)
         -> a
         -> q
    extQ :: forall a b q.
    (Typeable a, Typeable b) =>
    (a -> q) -> (b -> q) -> a -> q
    extQ a -> q
    f b -> q
    g a
    a = q -> (b -> q) -> Maybe b -> q
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (a -> q
    f a
    a) b -> q
    g (a -> Maybe b
    forall a b. (Typeable a, Typeable b) => a -> Maybe b
    cast a
    a)

    -- | Type extension of queries for type constructors
    ext1Q :: (Data d, Typeable t)
          => (d -> q)
          -> (forall e. Data e => t e -> q)
          -> d -> q
    ext1Q :: forall d (t :: * -> *) q.
    (Data d, Typeable t) =>
    (d -> q) -> (forall e. Data e => t e -> q) -> d -> q
    ext1Q d -> q
    def forall e. Data e => t e -> q
    ext = Q q d -> d -> q
    forall q x. Q q x -> x -> q
    unQ (((d -> q) -> Q q d
    forall q x. (x -> q) -> Q q x
    Q d -> q
    def) Q q d -> (forall d. Data d => Q q (t d)) -> Q q d
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    c a -> (forall d. Data d => c (t d)) -> c a
    `ext1` ((t d -> q) -> Q q (t d)
    forall q x. (x -> q) -> Q q x
    Q t d -> q
    forall e. Data e => t e -> q
    ext))

    -- | Type extension of queries for type constructors
    ext2Q :: (Data d, Typeable t)
          => (d -> q)
          -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q)
          -> d -> q
    ext2Q :: forall d (t :: * -> * -> *) q.
    (Data d, Typeable t) =>
    (d -> q)
    -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) -> d -> q
    ext2Q d -> q
    def forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q
    ext = Q q d -> d -> q
    forall q x. Q q x -> x -> q
    unQ (((d -> q) -> Q q d
    forall q x. (x -> q) -> Q q x
    Q d -> q
    def) Q q d
    -> (forall d1 d2. (Data d1, Data d2) => Q q (t d1 d2)) -> Q q d
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    c a -> (forall d1 d2. (Data d1, Data d2) => c (t d1 d2)) -> c a
    `ext2` ((t d1 d2 -> q) -> Q q (t d1 d2)
    forall q x. (x -> q) -> Q q x
    Q t d1 d2 -> q
    forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q
    ext))

    -- | Flexible type extension
    ext1 :: (Data a, Typeable t)
         => c a
         -> (forall d. Data d => c (t d))
         -> c a
    ext1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    c a -> (forall d. Data d => c (t d)) -> c a
    ext1 c a
    def forall d. Data d => c (t d)
    ext = c a -> (c a -> c a) -> Maybe (c a) -> c a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe c a
    def c a -> c a
    forall a. a -> a
    id ((forall d. Data d => c (t d)) -> Maybe (c a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c a)
    dataCast1 forall d. Data d => c (t d)
    ext)

    -- | Flexible type extension
    ext2 :: (Data a, Typeable t)
         => c a
         -> (forall d1 d2. (Data d1, Data d2) => c (t d1 d2))
         -> c a
    ext2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    c a -> (forall d1 d2. (Data d1, Data d2) => c (t d1 d2)) -> c a
    ext2 c a
    def forall d1 d2. (Data d1, Data d2) => c (t d1 d2)
    ext = c a -> (c a -> c a) -> Maybe (c a) -> c a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe c a
    def c a -> c a
    forall a. a -> a
    id ((forall d1 d2. (Data d1, Data d2) => c (t d1 d2)) -> Maybe (c a)
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
    dataCast2 forall d1 d2. (Data d1, Data d2) => c (t d1 d2)
    ext)