    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFunctor #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE KindSignatures #-}
    {-# LANGUAGE StandaloneDeriving #-}

    module GHC.Parser.Annotation (
      -- * Core Exact Print Annotation types
      EpToken(..), EpUniToken(..),
      getEpTokenSrcSpan,
      getEpTokenLocs, getEpTokenLoc, getEpUniTokenLoc,
      TokDcolon, TokDarrow, TokRarrow, TokForall,
      EpLayout(..),
      EpaComment(..), EpaCommentTok(..),
      IsUnicodeSyntax(..),
      HasE(..),

      -- * In-tree Exact Print Annotations
      EpaLocation, EpaLocation'(..), epaLocationRealSrcSpan,
      TokenLocation(..),
      DeltaPos(..), deltaPos, getDeltaLine,

      EpAnn(..),
      spanAsAnchor, realSpanAsAnchor,
      noSpanAnchor,
      NoAnn(..),

      -- ** Comments in Annotations

      EpAnnComments(..), LEpaComment, NoCommentsLocation, NoComments(..), emptyComments,
      epaToNoCommentsLocation, noCommentsToEpaLocation,
      getFollowingComments, setFollowingComments, setPriorComments,
      EpAnnCO,

      -- ** Annotations in 'GenLocated'
      LocatedA, LocatedL, LocatedC, LocatedN, LocatedAn, LocatedP,
      LocatedLC, LocatedLS, LocatedLW, LocatedLI,
      SrcSpanAnnA, SrcSpanAnnL, SrcSpanAnnP, SrcSpanAnnC, SrcSpanAnnN,
      SrcSpanAnnLC, SrcSpanAnnLW, SrcSpanAnnLS, SrcSpanAnnLI,
      LocatedE,

      -- ** Annotation data types used in 'GenLocated'

      AnnListItem(..), AnnList(..), AnnListBrackets(..),
      AnnParen(..),
      AnnPragma(..),
      AnnContext(..),
      NameAnn(..), NameAdornment(..),
      NoEpAnns(..),
      AnnSortKey(..), DeclTag(..), BindTag(..),

      -- ** Trailing annotations in lists
      TrailingAnn(..), ta_location,
      addTrailingAnnToA, addTrailingAnnToL, addTrailingCommaToN,
      noTrailingN,

      -- ** Utilities for converting between different 'GenLocated' when
      -- ** we do not care about the annotations.
      l2l, la2la,
      reLoc,
      HasLoc(..), getHasLocList,

      srcSpan2e, realSrcSpan,

      -- ** Building up annotations
      reAnnL, reAnnC,
      addAnnsA, widenSpanL, widenSpanT, widenAnchorT, widenAnchorS,
      widenLocatedAnL,
      listLocation,

      -- ** Querying annotations
      getLocAnn,
      epAnnComments,

      -- ** Working with locations of annotations
      sortLocatedA,
      mapLocA,
      combineLocsA,
      combineSrcSpansA,
      addCLocA,

      -- ** Constructing 'GenLocated' annotation types when we do not care
      -- about annotations.
      HasAnnotation(..),
      locA,
      noLocA,
      getLocA,
      noSrcSpanA,

      -- ** Working with comments in annotations
      noComments, comment, addCommentsToEpAnn, setCommentsEpAnn,
      transferAnnsA, transferAnnsOnlyA, transferCommentsOnlyA,
      transferPriorCommentsA, transferFollowingA,
      commentsOnlyA, removeCommentsA,

      placeholderRealSpan,
      ) where

    import GHC.Prelude

    import Data.Data
    import Data.Function (on)
    import Data.List (sortBy, foldl1')
    import Data.Semigroup
    import GHC.Data.FastString
    import GHC.TypeLits (Symbol, KnownSymbol, symbolVal)
    import GHC.Types.Name
    import GHC.Types.SrcLoc
    import GHC.Hs.DocString
    import GHC.Utils.Outputable hiding ( (<>) )
    import GHC.Utils.Panic
    import qualified GHC.Data.Strict as Strict
    import GHC.Types.SourceText (SourceText (NoSourceText))

    {-
    Note [exact print annotations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Given a parse tree of a Haskell module, how can we reconstruct
    the original Haskell source code, retaining all whitespace and
    source code comments?  We need to track the locations of all
    elements from the original source: this includes keywords such as
    'let' / 'in' / 'do' etc as well as punctuation such as commas and
    braces, and also comments.  We collectively refer to this
    metadata as the "exact print annotations".

    NON-COMMENT ELEMENTS

    Intuitively, every AST element directly contains a bag of keywords
    (keywords can show up more than once in a node: a semicolon i.e. newline
    can show up multiple times before the next AST element), each of which
    needs to be associated with its location in the original source code.

    These keywords are recorded directly in the AST element in which they
    occur, for the GhcPs phase.

    For any given element in the AST, there is only a set number of
    keywords that are applicable for it (e.g., you'll never see an
    'import' keyword associated with a let-binding.)  The set of allowed
    keywords is documented in a comment associated with the constructor
    of a given AST element, although the ground truth is in GHC.Parser
    and GHC.Parser.PostProcess (which actually add the annotations).

    COMMENT ELEMENTS

    We associate comments with the lowest (most specific) AST element
    enclosing them

    PARSER STATE

    There are three fields in PState (the parser state) which play a role
    with annotation comments.

    >  comment_q :: [LEpaComment],
    >  header_comments :: Maybe [LEpaComment],
    >  eof_pos :: Maybe (RealSrcSpan, RealSrcSpan), -- pos, gap to prior token

    The 'comment_q' field captures comments as they are seen in the token stream,
    so that when they are ready to be allocated via the parser they are
    available.

    The 'header_comments' capture the comments coming at the top of the
    source file.  They are moved there from the `comment_q` when comments
    are allocated for the first top-level declaration.

    The 'eof_pos' captures the final location in the file, and the
    location of the immediately preceding token to the last location, so
    that the exact-printer can work out how far to advance to add the
    trailing whitespace.

    PARSER EMISSION OF ANNOTATIONS

    The parser interacts with the lexer using the functions

    > getCommentsFor      :: (MonadP m) => SrcSpan -> m EpAnnComments
    > getPriorCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments
    > getFinalCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments

    The 'getCommentsFor' function is the one used most often.  It takes
    the AST element SrcSpan and removes and returns any comments in the
    'comment_q' that are inside the span. 'allocateComments' in 'Lexer' is
    responsible for making sure we only return comments that actually fit
    in the 'SrcSpan'.

    The 'getPriorCommentsFor' function is used for top-level declarations,
    and removes and returns any comments in the 'comment_q' that either
    precede or are included in the given SrcSpan. This is to ensure that
    preceding documentation comments are kept together with the
    declaration they belong to.

    The 'getFinalCommentsFor' function is called right at the end when EOF
    is hit. This drains the 'comment_q' completely, and returns the
    'header_comments', remaining 'comment_q' entries and the
    'eof_pos'. These values are inserted into the 'HsModule' AST element.

    The wiki page describing this feature is
    https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations

    -}

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

    -- | Certain tokens can have alternate representations when unicode syntax is
    -- enabled. This flag is attached to those tokens in the lexer so that the
    -- original source representation can be reproduced in the corresponding
    -- 'EpAnnotation'
    data IsUnicodeSyntax = UnicodeSyntax | NormalSyntax
        deriving (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool)
    -> Eq IsUnicodeSyntax
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    == :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    $c/= :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    /= :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    Eq, Eq IsUnicodeSyntax
    Eq IsUnicodeSyntax =>
    (IsUnicodeSyntax -> IsUnicodeSyntax -> Ordering)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> Bool)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax)
    -> (IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax)
    -> Ord IsUnicodeSyntax
    IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    IsUnicodeSyntax -> IsUnicodeSyntax -> Ordering
    IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: IsUnicodeSyntax -> IsUnicodeSyntax -> Ordering
    compare :: IsUnicodeSyntax -> IsUnicodeSyntax -> Ordering
    $c< :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    < :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    $c<= :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    <= :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    $c> :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    > :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    $c>= :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    >= :: IsUnicodeSyntax -> IsUnicodeSyntax -> Bool
    $cmax :: IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax
    max :: IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax
    $cmin :: IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax
    min :: IsUnicodeSyntax -> IsUnicodeSyntax -> IsUnicodeSyntax
    Ord, Typeable IsUnicodeSyntax
    Typeable IsUnicodeSyntax =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> IsUnicodeSyntax -> c IsUnicodeSyntax)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c IsUnicodeSyntax)
    -> (IsUnicodeSyntax -> Constr)
    -> (IsUnicodeSyntax -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c IsUnicodeSyntax))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c IsUnicodeSyntax))
    -> ((forall b. Data b => b -> b)
        -> IsUnicodeSyntax -> IsUnicodeSyntax)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> IsUnicodeSyntax -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> IsUnicodeSyntax -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> IsUnicodeSyntax -> m IsUnicodeSyntax)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> IsUnicodeSyntax -> m IsUnicodeSyntax)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> IsUnicodeSyntax -> m IsUnicodeSyntax)
    -> Data IsUnicodeSyntax
    IsUnicodeSyntax -> Constr
    IsUnicodeSyntax -> DataType
    (forall b. Data b => b -> b) -> IsUnicodeSyntax -> IsUnicodeSyntax
    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) -> IsUnicodeSyntax -> u
    forall u. (forall d. Data d => d -> u) -> IsUnicodeSyntax -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IsUnicodeSyntax
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IsUnicodeSyntax -> c IsUnicodeSyntax
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IsUnicodeSyntax)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IsUnicodeSyntax)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IsUnicodeSyntax -> c IsUnicodeSyntax
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IsUnicodeSyntax -> c IsUnicodeSyntax
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IsUnicodeSyntax
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IsUnicodeSyntax
    $ctoConstr :: IsUnicodeSyntax -> Constr
    toConstr :: IsUnicodeSyntax -> Constr
    $cdataTypeOf :: IsUnicodeSyntax -> DataType
    dataTypeOf :: IsUnicodeSyntax -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IsUnicodeSyntax)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IsUnicodeSyntax)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IsUnicodeSyntax)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IsUnicodeSyntax)
    $cgmapT :: (forall b. Data b => b -> b) -> IsUnicodeSyntax -> IsUnicodeSyntax
    gmapT :: (forall b. Data b => b -> b) -> IsUnicodeSyntax -> IsUnicodeSyntax
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IsUnicodeSyntax -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> IsUnicodeSyntax -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> IsUnicodeSyntax -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> IsUnicodeSyntax -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> IsUnicodeSyntax -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IsUnicodeSyntax -> m IsUnicodeSyntax
    Data, Int -> IsUnicodeSyntax -> ShowS
    [IsUnicodeSyntax] -> ShowS
    IsUnicodeSyntax -> String
    (Int -> IsUnicodeSyntax -> ShowS)
    -> (IsUnicodeSyntax -> String)
    -> ([IsUnicodeSyntax] -> ShowS)
    -> Show IsUnicodeSyntax
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IsUnicodeSyntax -> ShowS
    showsPrec :: Int -> IsUnicodeSyntax -> ShowS
    $cshow :: IsUnicodeSyntax -> String
    show :: IsUnicodeSyntax -> String
    $cshowList :: [IsUnicodeSyntax] -> ShowS
    showList :: [IsUnicodeSyntax] -> ShowS
    Show)

    -- | Some template haskell tokens have two variants, one with an `e` the other
    -- not:
    --
    -- >  [| or [e|
    -- >  [|| or [e||
    --
    -- This type indicates whether the 'e' is present or not.
    data HasE = HasE | NoE
         deriving (HasE -> HasE -> Bool
    (HasE -> HasE -> Bool) -> (HasE -> HasE -> Bool) -> Eq HasE
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HasE -> HasE -> Bool
    == :: HasE -> HasE -> Bool
    $c/= :: HasE -> HasE -> Bool
    /= :: HasE -> HasE -> Bool
    Eq, Eq HasE
    Eq HasE =>
    (HasE -> HasE -> Ordering)
    -> (HasE -> HasE -> Bool)
    -> (HasE -> HasE -> Bool)
    -> (HasE -> HasE -> Bool)
    -> (HasE -> HasE -> Bool)
    -> (HasE -> HasE -> HasE)
    -> (HasE -> HasE -> HasE)
    -> Ord HasE
    HasE -> HasE -> Bool
    HasE -> HasE -> Ordering
    HasE -> HasE -> HasE
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: HasE -> HasE -> Ordering
    compare :: HasE -> HasE -> Ordering
    $c< :: HasE -> HasE -> Bool
    < :: HasE -> HasE -> Bool
    $c<= :: HasE -> HasE -> Bool
    <= :: HasE -> HasE -> Bool
    $c> :: HasE -> HasE -> Bool
    > :: HasE -> HasE -> Bool
    $c>= :: HasE -> HasE -> Bool
    >= :: HasE -> HasE -> Bool
    $cmax :: HasE -> HasE -> HasE
    max :: HasE -> HasE -> HasE
    $cmin :: HasE -> HasE -> HasE
    min :: HasE -> HasE -> HasE
    Ord, Typeable HasE
    Typeable HasE =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> HasE -> c HasE)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c HasE)
    -> (HasE -> Constr)
    -> (HasE -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c HasE))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HasE))
    -> ((forall b. Data b => b -> b) -> HasE -> HasE)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r)
    -> (forall u. (forall d. Data d => d -> u) -> HasE -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> HasE -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> HasE -> m HasE)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HasE -> m HasE)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> HasE -> m HasE)
    -> Data HasE
    HasE -> Constr
    HasE -> DataType
    (forall b. Data b => b -> b) -> HasE -> HasE
    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) -> HasE -> u
    forall u. (forall d. Data d => d -> u) -> HasE -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HasE
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HasE -> c HasE
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HasE)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HasE)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HasE -> c HasE
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> HasE -> c HasE
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HasE
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HasE
    $ctoConstr :: HasE -> Constr
    toConstr :: HasE -> Constr
    $cdataTypeOf :: HasE -> DataType
    dataTypeOf :: HasE -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HasE)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HasE)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HasE)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HasE)
    $cgmapT :: (forall b. Data b => b -> b) -> HasE -> HasE
    gmapT :: (forall b. Data b => b -> b) -> HasE -> HasE
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> HasE -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> HasE -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HasE -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HasE -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HasE -> m HasE
    Data, Int -> HasE -> ShowS
    [HasE] -> ShowS
    HasE -> String
    (Int -> HasE -> ShowS)
    -> (HasE -> String) -> ([HasE] -> ShowS) -> Show HasE
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> HasE -> ShowS
    showsPrec :: Int -> HasE -> ShowS
    $cshow :: HasE -> String
    show :: HasE -> String
    $cshowList :: [HasE] -> ShowS
    showList :: [HasE] -> ShowS
    Show)

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

    -- | A token stored in the syntax tree. For example, when parsing a
    -- let-expression, we store @EpToken "let"@ and @EpToken "in"@.
    -- The locations of those tokens can be used to faithfully reproduce
    -- (exactprint) the original program text.
    data EpToken (tok :: Symbol)
      = NoEpTok
      | EpTok !EpaLocation

    instance KnownSymbol tok => Outputable (EpToken tok) where
      ppr :: EpToken tok -> SDoc
    ppr EpToken tok
    _ = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (Proxy tok -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (forall {k} (t :: k). Proxy t
    forall (t :: Symbol). Proxy t
    Proxy @tok))

    -- | With @UnicodeSyntax@, there might be multiple ways to write the same
    -- token. For example an arrow could be either @->@ or @→@. This choice must be
    -- recorded in order to exactprint such tokens, so instead of @EpToken "->"@ we
    -- introduce @EpUniToken "->" "→"@.
    data EpUniToken (tok :: Symbol) (utok :: Symbol)
      = NoEpUniTok
      | EpUniTok !EpaLocation !IsUnicodeSyntax

    deriving instance Eq (EpToken tok)
    deriving instance Eq (EpUniToken tok utok)
    deriving instance KnownSymbol tok => Data (EpToken tok)
    deriving instance (KnownSymbol tok, KnownSymbol utok) => Data (EpUniToken tok utok)

    instance (KnownSymbol tok, KnownSymbol utok) => Outputable (EpUniToken tok utok) where
      ppr :: EpUniToken tok utok -> SDoc
    ppr EpUniToken tok utok
    NoEpUniTok                 = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (String -> SDoc) -> String -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Proxy tok -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (forall {k} (t :: k). Proxy t
    forall (t :: Symbol). Proxy t
    Proxy @tok)
      ppr (EpUniTok EpaLocation
    _ IsUnicodeSyntax
    NormalSyntax)  = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (String -> SDoc) -> String -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Proxy tok -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (forall {k} (t :: k). Proxy t
    forall (t :: Symbol). Proxy t
    Proxy @tok)
      ppr (EpUniTok EpaLocation
    _ IsUnicodeSyntax
    UnicodeSyntax) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text (String -> SDoc) -> String -> SDoc
    forall a b. (a -> b) -> a -> b
    $ Proxy utok -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (forall {k} (t :: k). Proxy t
    forall (t :: Symbol). Proxy t
    Proxy @utok)

    getEpTokenSrcSpan :: EpToken tok -> SrcSpan
    getEpTokenSrcSpan :: forall (tok :: Symbol). EpToken tok -> SrcSpan
    getEpTokenSrcSpan EpToken tok
    NoEpTok = SrcSpan
    noSrcSpan
    getEpTokenSrcSpan (EpTok EpaDelta{}) = SrcSpan
    noSrcSpan
    getEpTokenSrcSpan (EpTok (EpaSpan SrcSpan
    span)) = SrcSpan
    span

    getEpTokenLocs :: [EpToken tok] -> [EpaLocation]
    getEpTokenLocs :: forall (tok :: Symbol). [EpToken tok] -> [EpaLocation]
    getEpTokenLocs [EpToken tok]
    ls = (EpToken tok -> [EpaLocation]) -> [EpToken tok] -> [EpaLocation]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap EpToken tok -> [EpaLocation]
    forall {tok :: Symbol}. EpToken tok -> [EpaLocation]
    go [EpToken tok]
    ls
      where
        go :: EpToken tok -> [EpaLocation]
    go EpToken tok
    NoEpTok   = []
        go (EpTok EpaLocation
    l) = [EpaLocation
    l]

    getEpTokenLoc :: EpToken tok -> EpaLocation
    getEpTokenLoc :: forall (tok :: Symbol). EpToken tok -> EpaLocation
    getEpTokenLoc EpToken tok
    NoEpTok   = EpaLocation
    forall a. NoAnn a => a
    noAnn
    getEpTokenLoc (EpTok EpaLocation
    l) = EpaLocation
    l

    getEpUniTokenLoc :: EpUniToken tok toku -> EpaLocation
    getEpUniTokenLoc :: forall (tok :: Symbol) (toku :: Symbol).
    EpUniToken tok toku -> EpaLocation
    getEpUniTokenLoc EpUniToken tok toku
    NoEpUniTok     = EpaLocation
    forall a. NoAnn a => a
    noAnn
    getEpUniTokenLoc (EpUniTok EpaLocation
    l IsUnicodeSyntax
    _) = EpaLocation
    l

    -- TODO:AZ: check we have all of the unicode tokens
    type TokDcolon = EpUniToken "::" "∷"
    type TokDarrow = EpUniToken "=>"  "⇒"
    type TokRarrow = EpUniToken "->" "→"
    type TokForall = EpUniToken "forall" "∀"

    -- | Layout information for declarations.
    data EpLayout =

        -- | Explicit braces written by the user.
        --
        -- @
        -- class C a where { foo :: a; bar :: a }
        -- @
        EpExplicitBraces !(EpToken "{") !(EpToken "}")
      |
        -- | Virtual braces inserted by the layout algorithm.
        --
        -- @
        -- class C a where
        --   foo :: a
        --   bar :: a
        -- @
        EpVirtualBraces
          !Int -- ^ Layout column (indentation level, begins at 1)
      |
        -- | Empty or compiler-generated blocks do not have layout information
        -- associated with them.
        EpNoLayout

    deriving instance Data EpLayout

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

    data EpaComment =
      EpaComment
        { EpaComment -> EpaCommentTok
    ac_tok :: EpaCommentTok
        , EpaComment -> RealSrcSpan
    ac_prior_tok :: RealSrcSpan
        -- ^ The location of the prior token, used in exact printing.  The
        -- 'EpaComment' appears as an 'LEpaComment' containing its
        -- location.  The difference between the end of the prior token
        -- and the start of this location is used for the spacing when
        -- exact printing the comment.
        }
        deriving (EpaComment -> EpaComment -> Bool
    (EpaComment -> EpaComment -> Bool)
    -> (EpaComment -> EpaComment -> Bool) -> Eq EpaComment
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EpaComment -> EpaComment -> Bool
    == :: EpaComment -> EpaComment -> Bool
    $c/= :: EpaComment -> EpaComment -> Bool
    /= :: EpaComment -> EpaComment -> Bool
    Eq, Typeable EpaComment
    Typeable EpaComment =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> EpaComment -> c EpaComment)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c EpaComment)
    -> (EpaComment -> Constr)
    -> (EpaComment -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c EpaComment))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c EpaComment))
    -> ((forall b. Data b => b -> b) -> EpaComment -> EpaComment)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EpaComment -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EpaComment -> r)
    -> (forall u. (forall d. Data d => d -> u) -> EpaComment -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EpaComment -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment)
    -> Data EpaComment
    EpaComment -> Constr
    EpaComment -> DataType
    (forall b. Data b => b -> b) -> EpaComment -> EpaComment
    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) -> EpaComment -> u
    forall u. (forall d. Data d => d -> u) -> EpaComment -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaComment -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaComment -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpaComment
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaComment -> c EpaComment
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpaComment)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpaComment)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaComment -> c EpaComment
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaComment -> c EpaComment
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpaComment
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpaComment
    $ctoConstr :: EpaComment -> Constr
    toConstr :: EpaComment -> Constr
    $cdataTypeOf :: EpaComment -> DataType
    dataTypeOf :: EpaComment -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpaComment)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpaComment)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpaComment)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpaComment)
    $cgmapT :: (forall b. Data b => b -> b) -> EpaComment -> EpaComment
    gmapT :: (forall b. Data b => b -> b) -> EpaComment -> EpaComment
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaComment -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaComment -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaComment -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaComment -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> EpaComment -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EpaComment -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpaComment -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpaComment -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaComment -> m EpaComment
    Data, Int -> EpaComment -> ShowS
    [EpaComment] -> ShowS
    EpaComment -> String
    (Int -> EpaComment -> ShowS)
    -> (EpaComment -> String)
    -> ([EpaComment] -> ShowS)
    -> Show EpaComment
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EpaComment -> ShowS
    showsPrec :: Int -> EpaComment -> ShowS
    $cshow :: EpaComment -> String
    show :: EpaComment -> String
    $cshowList :: [EpaComment] -> ShowS
    showList :: [EpaComment] -> ShowS
    Show)

    data EpaCommentTok =
      -- Documentation annotations
        EpaDocComment      HsDocString -- ^ a docstring that can be pretty printed using pprHsDocString
      | EpaDocOptions      String     -- ^ doc options (prune, ignore-exports, etc)
      | EpaLineComment     String     -- ^ comment starting by "--"
      | EpaBlockComment    String     -- ^ comment in {- -}
        deriving (EpaCommentTok -> EpaCommentTok -> Bool
    (EpaCommentTok -> EpaCommentTok -> Bool)
    -> (EpaCommentTok -> EpaCommentTok -> Bool) -> Eq EpaCommentTok
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EpaCommentTok -> EpaCommentTok -> Bool
    == :: EpaCommentTok -> EpaCommentTok -> Bool
    $c/= :: EpaCommentTok -> EpaCommentTok -> Bool
    /= :: EpaCommentTok -> EpaCommentTok -> Bool
    Eq, Typeable EpaCommentTok
    Typeable EpaCommentTok =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> EpaCommentTok -> c EpaCommentTok)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c EpaCommentTok)
    -> (EpaCommentTok -> Constr)
    -> (EpaCommentTok -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c EpaCommentTok))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c EpaCommentTok))
    -> ((forall b. Data b => b -> b) -> EpaCommentTok -> EpaCommentTok)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r)
    -> (forall u. (forall d. Data d => d -> u) -> EpaCommentTok -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EpaCommentTok -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok)
    -> Data EpaCommentTok
    EpaCommentTok -> Constr
    EpaCommentTok -> DataType
    (forall b. Data b => b -> b) -> EpaCommentTok -> EpaCommentTok
    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) -> EpaCommentTok -> u
    forall u. (forall d. Data d => d -> u) -> EpaCommentTok -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpaCommentTok
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaCommentTok -> c EpaCommentTok
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpaCommentTok)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EpaCommentTok)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaCommentTok -> c EpaCommentTok
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaCommentTok -> c EpaCommentTok
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpaCommentTok
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpaCommentTok
    $ctoConstr :: EpaCommentTok -> Constr
    toConstr :: EpaCommentTok -> Constr
    $cdataTypeOf :: EpaCommentTok -> DataType
    dataTypeOf :: EpaCommentTok -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpaCommentTok)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpaCommentTok)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EpaCommentTok)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EpaCommentTok)
    $cgmapT :: (forall b. Data b => b -> b) -> EpaCommentTok -> EpaCommentTok
    gmapT :: (forall b. Data b => b -> b) -> EpaCommentTok -> EpaCommentTok
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> EpaCommentTok -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EpaCommentTok -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpaCommentTok -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpaCommentTok -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok
    Data, Int -> EpaCommentTok -> ShowS
    [EpaCommentTok] -> ShowS
    EpaCommentTok -> String
    (Int -> EpaCommentTok -> ShowS)
    -> (EpaCommentTok -> String)
    -> ([EpaCommentTok] -> ShowS)
    -> Show EpaCommentTok
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EpaCommentTok -> ShowS
    showsPrec :: Int -> EpaCommentTok -> ShowS
    $cshow :: EpaCommentTok -> String
    show :: EpaCommentTok -> String
    $cshowList :: [EpaCommentTok] -> ShowS
    showList :: [EpaCommentTok] -> ShowS
    Show)
    -- Note: these are based on the Token versions, but the Token type is
    -- defined in GHC.Parser.Lexer and bringing it in here would create a loop

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

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

    type EpaLocation = EpaLocation' [LEpaComment]

    epaToNoCommentsLocation :: EpaLocation -> NoCommentsLocation
    epaToNoCommentsLocation :: EpaLocation -> EpaLocation' NoComments
    epaToNoCommentsLocation (EpaSpan SrcSpan
    ss) = SrcSpan -> EpaLocation' NoComments
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    ss
    epaToNoCommentsLocation (EpaDelta SrcSpan
    ss DeltaPos
    dp []) = SrcSpan -> DeltaPos -> NoComments -> EpaLocation' NoComments
    forall a. SrcSpan -> DeltaPos -> a -> EpaLocation' a
    EpaDelta SrcSpan
    ss DeltaPos
    dp NoComments
    NoComments
    epaToNoCommentsLocation (EpaDelta SrcSpan
    _ DeltaPos
    _ [LEpaComment]
    _ ) = String -> EpaLocation' NoComments
    forall a. HasCallStack => String -> a
    panic String
    "epaToNoCommentsLocation"

    noCommentsToEpaLocation :: NoCommentsLocation -> EpaLocation
    noCommentsToEpaLocation :: EpaLocation' NoComments -> EpaLocation
    noCommentsToEpaLocation (EpaSpan SrcSpan
    ss) = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    ss
    noCommentsToEpaLocation (EpaDelta SrcSpan
    ss DeltaPos
    dp NoComments
    NoComments) = SrcSpan -> DeltaPos -> [LEpaComment] -> EpaLocation
    forall a. SrcSpan -> DeltaPos -> a -> EpaLocation' a
    EpaDelta SrcSpan
    ss DeltaPos
    dp []

    -- | Tokens embedded in the AST have an EpaLocation, unless they come from
    -- generated code (e.g. by TH).
    data TokenLocation = NoTokenLoc | TokenLoc !EpaLocation
                   deriving (Typeable TokenLocation
    Typeable TokenLocation =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TokenLocation -> c TokenLocation)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TokenLocation)
    -> (TokenLocation -> Constr)
    -> (TokenLocation -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TokenLocation))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c TokenLocation))
    -> ((forall b. Data b => b -> b) -> TokenLocation -> TokenLocation)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TokenLocation -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TokenLocation -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation)
    -> Data TokenLocation
    TokenLocation -> Constr
    TokenLocation -> DataType
    (forall b. Data b => b -> b) -> TokenLocation -> TokenLocation
    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) -> TokenLocation -> u
    forall u. (forall d. Data d => d -> u) -> TokenLocation -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TokenLocation
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TokenLocation -> c TokenLocation
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TokenLocation)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TokenLocation)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TokenLocation -> c TokenLocation
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TokenLocation -> c TokenLocation
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TokenLocation
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TokenLocation
    $ctoConstr :: TokenLocation -> Constr
    toConstr :: TokenLocation -> Constr
    $cdataTypeOf :: TokenLocation -> DataType
    dataTypeOf :: TokenLocation -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TokenLocation)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TokenLocation)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TokenLocation)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TokenLocation)
    $cgmapT :: (forall b. Data b => b -> b) -> TokenLocation -> TokenLocation
    gmapT :: (forall b. Data b => b -> b) -> TokenLocation -> TokenLocation
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenLocation -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TokenLocation -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TokenLocation -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TokenLocation -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TokenLocation -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenLocation -> m TokenLocation
    Data,TokenLocation -> TokenLocation -> Bool
    (TokenLocation -> TokenLocation -> Bool)
    -> (TokenLocation -> TokenLocation -> Bool) -> Eq TokenLocation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TokenLocation -> TokenLocation -> Bool
    == :: TokenLocation -> TokenLocation -> Bool
    $c/= :: TokenLocation -> TokenLocation -> Bool
    /= :: TokenLocation -> TokenLocation -> Bool
    Eq)

    instance Outputable a => Outputable (GenLocated TokenLocation a) where
      ppr :: GenLocated TokenLocation a -> SDoc
    ppr (L TokenLocation
    _ a
    x) = a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr a
    x

    -- | Used in the parser only, extract the 'RealSrcSpan' from an
    -- 'EpaLocation'. The parser will never insert a 'DeltaPos', so the
    -- partial function is safe.
    epaLocationRealSrcSpan :: EpaLocation' a -> RealSrcSpan
    epaLocationRealSrcSpan :: forall a. EpaLocation' a -> RealSrcSpan
    epaLocationRealSrcSpan (EpaSpan (RealSrcSpan RealSrcSpan
    r Maybe BufSpan
    _)) = RealSrcSpan
    r
    epaLocationRealSrcSpan EpaLocation' a
    _ = String -> RealSrcSpan
    forall a. HasCallStack => String -> a
    panic String
    "epaLocationRealSrcSpan"

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

    -- | The exact print annotations (EPAs) are kept in the HsSyn AST for
    --   the GhcPs phase. They are usually inserted into the AST by the parser,
    --   and in case of generated code (e.g. by TemplateHaskell) they are usually
    --   initialized using 'NoAnn' type class.
    --
    -- A goal of the annotations is that an AST can be edited, including
    -- moving subtrees from one place to another, duplicating them, and so
    -- on.  This means that each fragment must be self-contained.  To this
    -- end, each annotated fragment keeps track of the anchor position it
    -- was originally captured at, being simply the start span of the
    -- topmost element of the ast fragment.  This gives us a way to later
    -- re-calculate all Located items in this layer of the AST, as well as
    -- any annotations captured. The comments associated with the AST
    -- fragment are also captured here.
    --
    -- The 'ann' type parameter allows this general structure to be
    -- specialised to the specific set of locations of original exact
    -- print annotation elements.  For example
    --
    -- @
    -- type SrcSpannAnnA = EpAnn AnnListItem
    -- @
    --
    -- is a commonly used type alias that specializes the 'ann' type parameter to
    -- 'AnnListItem'.
    --
    -- The spacing between the items under the scope of a given EpAnn is
    -- normally derived from the original 'Anchor'.  But if a sub-element
    -- is not in its original position, the required spacing can be
    -- captured using an appropriate 'EpaDelta' value for the 'entry' Anchor.
    -- This allows us to freely move elements around, and stitch together
    -- new AST fragments out of old ones, and have them still printed out
    -- in a precise way.
    data EpAnn ann
      = EpAnn { forall ann. EpAnn ann -> EpaLocation
    entry   :: !EpaLocation
               -- ^ Base location for the start of the syntactic element
               -- holding the annotations.
               , forall ann. EpAnn ann -> ann
    anns     :: !ann -- ^ Annotations added by the Parser
               , forall ann. EpAnn ann -> EpAnnComments
    comments :: !EpAnnComments
                  -- ^ Comments enclosed in the SrcSpan of the element
                  -- this `EpAnn` is attached to
               }
            deriving (Typeable (EpAnn ann)
    Typeable (EpAnn ann) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> EpAnn ann -> c (EpAnn ann))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (EpAnn ann))
    -> (EpAnn ann -> Constr)
    -> (EpAnn ann -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (EpAnn ann)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (EpAnn ann)))
    -> ((forall b. Data b => b -> b) -> EpAnn ann -> EpAnn ann)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r)
    -> (forall u. (forall d. Data d => d -> u) -> EpAnn ann -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EpAnn ann -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann))
    -> Data (EpAnn ann)
    EpAnn ann -> Constr
    EpAnn ann -> DataType
    (forall b. Data b => b -> b) -> EpAnn ann -> EpAnn ann
    forall ann. Data ann => Typeable (EpAnn ann)
    forall ann. Data ann => EpAnn ann -> Constr
    forall ann. Data ann => EpAnn ann -> DataType
    forall ann.
    Data ann =>
    (forall b. Data b => b -> b) -> EpAnn ann -> EpAnn ann
    forall ann u.
    Data ann =>
    Int -> (forall d. Data d => d -> u) -> EpAnn ann -> u
    forall ann u.
    Data ann =>
    (forall d. Data d => d -> u) -> EpAnn ann -> [u]
    forall ann r r'.
    Data ann =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    forall ann r r'.
    Data ann =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    forall ann (m :: * -> *).
    (Data ann, Monad m) =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    forall ann (m :: * -> *).
    (Data ann, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    forall ann (c :: * -> *).
    Data ann =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpAnn ann)
    forall ann (c :: * -> *).
    Data ann =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnn ann -> c (EpAnn ann)
    forall ann (t :: * -> *) (c :: * -> *).
    (Data ann, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpAnn ann))
    forall ann (t :: * -> * -> *) (c :: * -> *).
    (Data ann, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpAnn ann))
    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) -> EpAnn ann -> u
    forall u. (forall d. Data d => d -> u) -> EpAnn ann -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpAnn ann)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnn ann -> c (EpAnn ann)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpAnn ann))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpAnn ann))
    $cgfoldl :: forall ann (c :: * -> *).
    Data ann =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnn ann -> c (EpAnn ann)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnn ann -> c (EpAnn ann)
    $cgunfold :: forall ann (c :: * -> *).
    Data ann =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpAnn ann)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpAnn ann)
    $ctoConstr :: forall ann. Data ann => EpAnn ann -> Constr
    toConstr :: EpAnn ann -> Constr
    $cdataTypeOf :: forall ann. Data ann => EpAnn ann -> DataType
    dataTypeOf :: EpAnn ann -> DataType
    $cdataCast1 :: forall ann (t :: * -> *) (c :: * -> *).
    (Data ann, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpAnn ann))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpAnn ann))
    $cdataCast2 :: forall ann (t :: * -> * -> *) (c :: * -> *).
    (Data ann, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpAnn ann))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpAnn ann))
    $cgmapT :: forall ann.
    Data ann =>
    (forall b. Data b => b -> b) -> EpAnn ann -> EpAnn ann
    gmapT :: (forall b. Data b => b -> b) -> EpAnn ann -> EpAnn ann
    $cgmapQl :: forall ann r r'.
    Data ann =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    $cgmapQr :: forall ann r r'.
    Data ann =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnn ann -> r
    $cgmapQ :: forall ann u.
    Data ann =>
    (forall d. Data d => d -> u) -> EpAnn ann -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EpAnn ann -> [u]
    $cgmapQi :: forall ann u.
    Data ann =>
    Int -> (forall d. Data d => d -> u) -> EpAnn ann -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpAnn ann -> u
    $cgmapM :: forall ann (m :: * -> *).
    (Data ann, Monad m) =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    $cgmapMp :: forall ann (m :: * -> *).
    (Data ann, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    $cgmapMo :: forall ann (m :: * -> *).
    (Data ann, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnn ann -> m (EpAnn ann)
    Data, EpAnn ann -> EpAnn ann -> Bool
    (EpAnn ann -> EpAnn ann -> Bool)
    -> (EpAnn ann -> EpAnn ann -> Bool) -> Eq (EpAnn ann)
    forall ann. Eq ann => EpAnn ann -> EpAnn ann -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall ann. Eq ann => EpAnn ann -> EpAnn ann -> Bool
    == :: EpAnn ann -> EpAnn ann -> Bool
    $c/= :: forall ann. Eq ann => EpAnn ann -> EpAnn ann -> Bool
    /= :: EpAnn ann -> EpAnn ann -> Bool
    Eq, (forall a b. (a -> b) -> EpAnn a -> EpAnn b)
    -> (forall a b. a -> EpAnn b -> EpAnn a) -> Functor EpAnn
    forall a b. a -> EpAnn b -> EpAnn a
    forall a b. (a -> b) -> EpAnn a -> EpAnn b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> EpAnn a -> EpAnn b
    fmap :: forall a b. (a -> b) -> EpAnn a -> EpAnn b
    $c<$ :: forall a b. a -> EpAnn b -> EpAnn a
    <$ :: forall a b. a -> EpAnn b -> EpAnn a
    Functor)
    -- See Note [XRec and Anno in the AST]

    spanAsAnchor :: SrcSpan -> (EpaLocation' a)
    spanAsAnchor :: forall a. SrcSpan -> EpaLocation' a
    spanAsAnchor SrcSpan
    ss  = SrcSpan -> EpaLocation' a
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    ss

    realSpanAsAnchor :: RealSrcSpan -> (EpaLocation' a)
    realSpanAsAnchor :: forall a. RealSrcSpan -> EpaLocation' a
    realSpanAsAnchor RealSrcSpan
    s = SrcSpan -> EpaLocation' a
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    forall a. Maybe a
    Strict.Nothing)

    noSpanAnchor :: (NoAnn a) => EpaLocation' a
    noSpanAnchor :: forall a. NoAnn a => EpaLocation' a
    noSpanAnchor =  SrcSpan -> DeltaPos -> a -> EpaLocation' a
    forall a. SrcSpan -> DeltaPos -> a -> EpaLocation' a
    EpaDelta SrcSpan
    noSrcSpan (Int -> DeltaPos
    SameLine Int
    0) a
    forall a. NoAnn a => a
    noAnn

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

    -- | When we are parsing we add comments that belong to a particular AST
    -- element, and print them together with the element, interleaving
    -- them into the output stream.  But when editing the AST to move
    -- fragments around it is useful to be able to first separate the
    -- comments into those occurring before the AST element and those
    -- following it.  The 'EpaCommentsBalanced' constructor is used to do
    -- this. The GHC parser will only insert the 'EpaComments' form.
    data EpAnnComments = EpaComments
                            { EpAnnComments -> [LEpaComment]
    priorComments :: ![LEpaComment] }
                        | EpaCommentsBalanced
                            { priorComments :: ![LEpaComment]
                            , EpAnnComments -> [LEpaComment]
    followingComments :: ![LEpaComment] }
            deriving (Typeable EpAnnComments
    Typeable EpAnnComments =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> EpAnnComments -> c EpAnnComments)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c EpAnnComments)
    -> (EpAnnComments -> Constr)
    -> (EpAnnComments -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c EpAnnComments))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c EpAnnComments))
    -> ((forall b. Data b => b -> b) -> EpAnnComments -> EpAnnComments)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r)
    -> (forall u. (forall d. Data d => d -> u) -> EpAnnComments -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EpAnnComments -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments)
    -> Data EpAnnComments
    EpAnnComments -> Constr
    EpAnnComments -> DataType
    (forall b. Data b => b -> b) -> EpAnnComments -> EpAnnComments
    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) -> EpAnnComments -> u
    forall u. (forall d. Data d => d -> u) -> EpAnnComments -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpAnnComments
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnnComments -> c EpAnnComments
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpAnnComments)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EpAnnComments)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnnComments -> c EpAnnComments
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpAnnComments -> c EpAnnComments
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpAnnComments
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EpAnnComments
    $ctoConstr :: EpAnnComments -> Constr
    toConstr :: EpAnnComments -> Constr
    $cdataTypeOf :: EpAnnComments -> DataType
    dataTypeOf :: EpAnnComments -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpAnnComments)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EpAnnComments)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EpAnnComments)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EpAnnComments)
    $cgmapT :: (forall b. Data b => b -> b) -> EpAnnComments -> EpAnnComments
    gmapT :: (forall b. Data b => b -> b) -> EpAnnComments -> EpAnnComments
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpAnnComments -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> EpAnnComments -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EpAnnComments -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpAnnComments -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EpAnnComments -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EpAnnComments -> m EpAnnComments
    Data, EpAnnComments -> EpAnnComments -> Bool
    (EpAnnComments -> EpAnnComments -> Bool)
    -> (EpAnnComments -> EpAnnComments -> Bool) -> Eq EpAnnComments
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EpAnnComments -> EpAnnComments -> Bool
    == :: EpAnnComments -> EpAnnComments -> Bool
    $c/= :: EpAnnComments -> EpAnnComments -> Bool
    /= :: EpAnnComments -> EpAnnComments -> Bool
    Eq)

    type LEpaComment = GenLocated NoCommentsLocation EpaComment

    emptyComments :: EpAnnComments
    emptyComments :: EpAnnComments
    emptyComments = [LEpaComment] -> EpAnnComments
    EpaComments []

    -- ---------------------------------------------------------------------
    -- Annotations attached to a 'SrcSpan'.
    -- ---------------------------------------------------------------------

    type LocatedA = GenLocated SrcSpanAnnA
    type LocatedN = GenLocated SrcSpanAnnN

    type LocatedL = GenLocated SrcSpanAnnL
    type LocatedLC = GenLocated SrcSpanAnnLC
    type LocatedLS = GenLocated SrcSpanAnnLS
    type LocatedLW = GenLocated SrcSpanAnnLW
    type LocatedLI = GenLocated SrcSpanAnnLI
    type LocatedP = GenLocated SrcSpanAnnP
    type LocatedC = GenLocated SrcSpanAnnC

    type SrcSpanAnnA = EpAnn AnnListItem
    type SrcSpanAnnN = EpAnn NameAnn

    type SrcSpanAnnL = EpAnn (AnnList ())
    type SrcSpanAnnLC = EpAnn (AnnList [EpToken ","])
    type SrcSpanAnnLS = EpAnn (AnnList ())
    type SrcSpanAnnLW = EpAnn (AnnList (EpToken "where"))
    type SrcSpanAnnLI = EpAnn (AnnList (EpToken "hiding", [EpToken ","]))
    type SrcSpanAnnP = EpAnn AnnPragma
    type SrcSpanAnnC = EpAnn AnnContext

    type LocatedE = GenLocated EpaLocation

    -- | General representation of a 'GenLocated' type carrying a
    -- parameterised annotation type.
    type LocatedAn an = GenLocated (EpAnn an)

    {-
    Note [XRec and Anno in the AST]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    The exact print annotations are captured directly inside the AST, using
    TTG extension points. However certain annotations need to be captured
    on the Located versions too.  There is a general form for these,
    captured in the type 'EpAnn ann' with the specific usage captured in
    the 'ann' parameter in different contexts.

    Some of the particular use cases are

    1) RdrNames, which can have additional items such as backticks or parens

    2) Items which occur in lists, and the annotation relates purely
    to its usage inside a list.

    See the section above this note for the rest.

    The Anno type family maps to the specific EpAnn variant for a given
    item.

    So

      type instance XRec (GhcPass p) a = GenLocated (Anno a) a
      type instance Anno RdrName = SrcSpanAnnN
      type LocatedN = GenLocated SrcSpanAnnN

    meaning we can have type LocatedN RdrName

    -}

    -- ---------------------------------------------------------------------
    -- Annotations for items in a list
    -- ---------------------------------------------------------------------

    -- | Captures the location of punctuation occurring between items,
    -- normally in a list.  It is captured as a trailing annotation.
    data TrailingAnn
      = AddSemiAnn    (EpToken ";") -- ^ Trailing ';'
      | AddCommaAnn   (EpToken ",") -- ^ Trailing ','
      | AddVbarAnn    (EpToken "|") -- ^ Trailing '|'
      | AddDarrowAnn  TokDarrow     -- ^ Trailing '=>' / '⇒'
      deriving (Typeable TrailingAnn
    Typeable TrailingAnn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> TrailingAnn -> c TrailingAnn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TrailingAnn)
    -> (TrailingAnn -> Constr)
    -> (TrailingAnn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TrailingAnn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c TrailingAnn))
    -> ((forall b. Data b => b -> b) -> TrailingAnn -> TrailingAnn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TrailingAnn -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TrailingAnn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn)
    -> Data TrailingAnn
    TrailingAnn -> Constr
    TrailingAnn -> DataType
    (forall b. Data b => b -> b) -> TrailingAnn -> TrailingAnn
    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) -> TrailingAnn -> u
    forall u. (forall d. Data d => d -> u) -> TrailingAnn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TrailingAnn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TrailingAnn -> c TrailingAnn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TrailingAnn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TrailingAnn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TrailingAnn -> c TrailingAnn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TrailingAnn -> c TrailingAnn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TrailingAnn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TrailingAnn
    $ctoConstr :: TrailingAnn -> Constr
    toConstr :: TrailingAnn -> Constr
    $cdataTypeOf :: TrailingAnn -> DataType
    dataTypeOf :: TrailingAnn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TrailingAnn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TrailingAnn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TrailingAnn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TrailingAnn)
    $cgmapT :: (forall b. Data b => b -> b) -> TrailingAnn -> TrailingAnn
    gmapT :: (forall b. Data b => b -> b) -> TrailingAnn -> TrailingAnn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TrailingAnn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TrailingAnn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TrailingAnn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TrailingAnn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn
    Data, TrailingAnn -> TrailingAnn -> Bool
    (TrailingAnn -> TrailingAnn -> Bool)
    -> (TrailingAnn -> TrailingAnn -> Bool) -> Eq TrailingAnn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TrailingAnn -> TrailingAnn -> Bool
    == :: TrailingAnn -> TrailingAnn -> Bool
    $c/= :: TrailingAnn -> TrailingAnn -> Bool
    /= :: TrailingAnn -> TrailingAnn -> Bool
    Eq)

    ta_location :: TrailingAnn -> EpaLocation
    ta_location :: TrailingAnn -> EpaLocation
    ta_location (AddSemiAnn    EpToken ";"
    tok) = EpToken ";" -> EpaLocation
    forall (tok :: Symbol). EpToken tok -> EpaLocation
    getEpTokenLoc EpToken ";"
    tok
    ta_location (AddCommaAnn   EpToken ","
    tok) = EpToken "," -> EpaLocation
    forall (tok :: Symbol). EpToken tok -> EpaLocation
    getEpTokenLoc EpToken ","
    tok
    ta_location (AddVbarAnn    EpToken "|"
    tok) = EpToken "|" -> EpaLocation
    forall (tok :: Symbol). EpToken tok -> EpaLocation
    getEpTokenLoc EpToken "|"
    tok
    ta_location (AddDarrowAnn  TokDarrow
    tok) = TokDarrow -> EpaLocation
    forall (tok :: Symbol) (toku :: Symbol).
    EpUniToken tok toku -> EpaLocation
    getEpUniTokenLoc TokDarrow
    tok

    instance Outputable TrailingAnn where
      ppr :: TrailingAnn -> SDoc
    ppr (AddSemiAnn EpToken ";"
    tok)    = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AddSemiAnn"    SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken ";" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken ";"
    tok
      ppr (AddCommaAnn EpToken ","
    tok)   = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AddCommaAnn"   SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "," -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken ","
    tok
      ppr (AddVbarAnn EpToken "|"
    tok)    = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AddVbarAnn"    SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "|" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "|"
    tok
      ppr (AddDarrowAnn TokDarrow
    tok)  = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AddDarrowAnn"  SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TokDarrow -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TokDarrow
    tok

    -- | Annotation for items appearing in a list. They can have one or
    -- more trailing punctuations items, such as commas or semicolons.
    data AnnListItem
      = AnnListItem {
          AnnListItem -> [TrailingAnn]
    lann_trailing  :: [TrailingAnn]
          }
      deriving (Typeable AnnListItem
    Typeable AnnListItem =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnListItem -> c AnnListItem)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnListItem)
    -> (AnnListItem -> Constr)
    -> (AnnListItem -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnListItem))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnListItem))
    -> ((forall b. Data b => b -> b) -> AnnListItem -> AnnListItem)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnListItem -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnListItem -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem)
    -> Data AnnListItem
    AnnListItem -> Constr
    AnnListItem -> DataType
    (forall b. Data b => b -> b) -> AnnListItem -> AnnListItem
    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) -> AnnListItem -> u
    forall u. (forall d. Data d => d -> u) -> AnnListItem -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnListItem
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnListItem -> c AnnListItem
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnListItem)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnListItem)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnListItem -> c AnnListItem
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnListItem -> c AnnListItem
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnListItem
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnListItem
    $ctoConstr :: AnnListItem -> Constr
    toConstr :: AnnListItem -> Constr
    $cdataTypeOf :: AnnListItem -> DataType
    dataTypeOf :: AnnListItem -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnListItem)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnListItem)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnListItem)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnListItem)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnListItem -> AnnListItem
    gmapT :: (forall b. Data b => b -> b) -> AnnListItem -> AnnListItem
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListItem -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnListItem -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnListItem -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnListItem -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnListItem -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnListItem -> m AnnListItem
    Data, AnnListItem -> AnnListItem -> Bool
    (AnnListItem -> AnnListItem -> Bool)
    -> (AnnListItem -> AnnListItem -> Bool) -> Eq AnnListItem
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AnnListItem -> AnnListItem -> Bool
    == :: AnnListItem -> AnnListItem -> Bool
    $c/= :: AnnListItem -> AnnListItem -> Bool
    /= :: AnnListItem -> AnnListItem -> Bool
    Eq)

    -- ---------------------------------------------------------------------
    -- Annotations for the context of a list of items
    -- ---------------------------------------------------------------------

    -- | Annotation for the "container" of a list. This captures
    -- surrounding items such as braces if present, and introductory
    -- keywords such as 'where'.
    data AnnList a
      = AnnList {
          forall a. AnnList a -> Maybe EpaLocation
    al_anchor    :: !(Maybe EpaLocation), -- ^ start point of a list having layout
          forall a. AnnList a -> AnnListBrackets
    al_brackets  :: !AnnListBrackets,
          forall a. AnnList a -> [EpToken ";"]
    al_semis     :: [EpToken ";"], -- decls
          forall a. AnnList a -> a
    al_rest      :: !a,
          forall a. AnnList a -> [TrailingAnn]
    al_trailing  :: ![TrailingAnn] -- ^ items appearing after the
                                         -- list, such as '=>' for a
                                         -- context
          } deriving (Typeable (AnnList a)
    Typeable (AnnList a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnList a -> c (AnnList a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (AnnList a))
    -> (AnnList a -> Constr)
    -> (AnnList a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (AnnList a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (AnnList a)))
    -> ((forall b. Data b => b -> b) -> AnnList a -> AnnList a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnList a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnList a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnList a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnList a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a))
    -> Data (AnnList a)
    AnnList a -> Constr
    AnnList a -> DataType
    (forall b. Data b => b -> b) -> AnnList a -> AnnList a
    forall a. Data a => Typeable (AnnList a)
    forall a. Data a => AnnList a -> Constr
    forall a. Data a => AnnList a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> AnnList a -> AnnList a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> AnnList a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> AnnList a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnList a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnList a -> c (AnnList a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnList a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnList a))
    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) -> AnnList a -> u
    forall u. (forall d. Data d => d -> u) -> AnnList a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnList a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnList a -> c (AnnList a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnList a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnList a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnList a -> c (AnnList a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnList a -> c (AnnList a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnList a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnList a)
    $ctoConstr :: forall a. Data a => AnnList a -> Constr
    toConstr :: AnnList a -> Constr
    $cdataTypeOf :: forall a. Data a => AnnList a -> DataType
    dataTypeOf :: AnnList a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnList a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnList a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnList a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnList a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> AnnList a -> AnnList a
    gmapT :: (forall b. Data b => b -> b) -> AnnList a -> AnnList a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnList a -> r
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> AnnList a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnList a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> AnnList a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnList a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a)
    Data,AnnList a -> AnnList a -> Bool
    (AnnList a -> AnnList a -> Bool)
    -> (AnnList a -> AnnList a -> Bool) -> Eq (AnnList a)
    forall a. Eq a => AnnList a -> AnnList a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => AnnList a -> AnnList a -> Bool
    == :: AnnList a -> AnnList a -> Bool
    $c/= :: forall a. Eq a => AnnList a -> AnnList a -> Bool
    /= :: AnnList a -> AnnList a -> Bool
    Eq)

    data AnnListBrackets
      = ListParens (EpToken "(")         (EpToken ")")
      | ListBraces (EpToken "{")         (EpToken "}")
      | ListSquare (EpToken "[")         (EpToken "]")
      | ListBanana (EpUniToken "(|" "⦇") (EpUniToken "|)"  "⦈")
      | ListNone
      deriving (Typeable AnnListBrackets
    Typeable AnnListBrackets =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnListBrackets -> c AnnListBrackets)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnListBrackets)
    -> (AnnListBrackets -> Constr)
    -> (AnnListBrackets -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnListBrackets))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnListBrackets))
    -> ((forall b. Data b => b -> b)
        -> AnnListBrackets -> AnnListBrackets)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> AnnListBrackets -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnListBrackets -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> AnnListBrackets -> m AnnListBrackets)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnListBrackets -> m AnnListBrackets)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnListBrackets -> m AnnListBrackets)
    -> Data AnnListBrackets
    AnnListBrackets -> Constr
    AnnListBrackets -> DataType
    (forall b. Data b => b -> b) -> AnnListBrackets -> AnnListBrackets
    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) -> AnnListBrackets -> u
    forall u. (forall d. Data d => d -> u) -> AnnListBrackets -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnListBrackets
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnListBrackets -> c AnnListBrackets
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnListBrackets)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnListBrackets)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnListBrackets -> c AnnListBrackets
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnListBrackets -> c AnnListBrackets
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnListBrackets
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnListBrackets
    $ctoConstr :: AnnListBrackets -> Constr
    toConstr :: AnnListBrackets -> Constr
    $cdataTypeOf :: AnnListBrackets -> DataType
    dataTypeOf :: AnnListBrackets -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnListBrackets)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnListBrackets)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnListBrackets)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AnnListBrackets)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnListBrackets -> AnnListBrackets
    gmapT :: (forall b. Data b => b -> b) -> AnnListBrackets -> AnnListBrackets
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnListBrackets -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnListBrackets -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnListBrackets -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnListBrackets -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnListBrackets -> m AnnListBrackets
    Data,AnnListBrackets -> AnnListBrackets -> Bool
    (AnnListBrackets -> AnnListBrackets -> Bool)
    -> (AnnListBrackets -> AnnListBrackets -> Bool)
    -> Eq AnnListBrackets
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AnnListBrackets -> AnnListBrackets -> Bool
    == :: AnnListBrackets -> AnnListBrackets -> Bool
    $c/= :: AnnListBrackets -> AnnListBrackets -> Bool
    /= :: AnnListBrackets -> AnnListBrackets -> Bool
    Eq)

    -- ---------------------------------------------------------------------
    -- Annotations for parenthesised elements, such as tuples, lists
    -- ---------------------------------------------------------------------

    -- | exact print annotation for an item having surrounding "brackets", such as
    -- tuples or lists
    data AnnParen
      = AnnParens       (EpToken "(")  (EpToken ")")  -- ^ '(', ')'
      | AnnParensHash   (EpToken "(#") (EpToken "#)") -- ^ '(#', '#)'
      | AnnParensSquare (EpToken "[")  (EpToken "]")  -- ^ '[', ']'
      deriving Typeable AnnParen
    Typeable AnnParen =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnParen -> c AnnParen)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnParen)
    -> (AnnParen -> Constr)
    -> (AnnParen -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnParen))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnParen))
    -> ((forall b. Data b => b -> b) -> AnnParen -> AnnParen)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnParen -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnParen -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnParen -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> AnnParen -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen)
    -> Data AnnParen
    AnnParen -> Constr
    AnnParen -> DataType
    (forall b. Data b => b -> b) -> AnnParen -> AnnParen
    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) -> AnnParen -> u
    forall u. (forall d. Data d => d -> u) -> AnnParen -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnParen -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnParen -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnParen
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnParen -> c AnnParen
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnParen)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnParen)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnParen -> c AnnParen
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnParen -> c AnnParen
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnParen
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnParen
    $ctoConstr :: AnnParen -> Constr
    toConstr :: AnnParen -> Constr
    $cdataTypeOf :: AnnParen -> DataType
    dataTypeOf :: AnnParen -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnParen)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnParen)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnParen)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnParen)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnParen -> AnnParen
    gmapT :: (forall b. Data b => b -> b) -> AnnParen -> AnnParen
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnParen -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnParen -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnParen -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnParen -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnParen -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnParen -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnParen -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnParen -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen
    Data

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

    -- | Exact print annotation for the 'Context' data type.
    data AnnContext
      = AnnContext {
          AnnContext -> Maybe TokDarrow
    ac_darrow    :: Maybe TokDarrow,
                          -- ^ location of the '=>', if present.
          AnnContext -> [EpToken "("]
    ac_open      :: [EpToken "("], -- ^ zero or more opening parentheses.
          AnnContext -> [EpToken ")"]
    ac_close     :: [EpToken ")"]  -- ^ zero or more closing parentheses.
          } deriving (Typeable AnnContext
    Typeable AnnContext =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnContext -> c AnnContext)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnContext)
    -> (AnnContext -> Constr)
    -> (AnnContext -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnContext))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c AnnContext))
    -> ((forall b. Data b => b -> b) -> AnnContext -> AnnContext)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnContext -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnContext -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnContext -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnContext -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext)
    -> Data AnnContext
    AnnContext -> Constr
    AnnContext -> DataType
    (forall b. Data b => b -> b) -> AnnContext -> AnnContext
    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) -> AnnContext -> u
    forall u. (forall d. Data d => d -> u) -> AnnContext -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnContext -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnContext -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnContext
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnContext -> c AnnContext
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnContext)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnContext)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnContext -> c AnnContext
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnContext -> c AnnContext
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnContext
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnContext
    $ctoConstr :: AnnContext -> Constr
    toConstr :: AnnContext -> Constr
    $cdataTypeOf :: AnnContext -> DataType
    dataTypeOf :: AnnContext -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnContext)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnContext)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnContext)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnContext)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnContext -> AnnContext
    gmapT :: (forall b. Data b => b -> b) -> AnnContext -> AnnContext
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnContext -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnContext -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnContext -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnContext -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnContext -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnContext -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnContext -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnContext -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext
    Data)

    -- ---------------------------------------------------------------------
    -- Annotations for names
    -- ---------------------------------------------------------------------

    -- | exact print annotations for a 'RdrName'.  There are many kinds of
    -- adornment that can be attached to a given 'RdrName'. This type
    -- captures them, as detailed on the individual constructors.
    data NameAnn
      -- | Used for a name with an adornment, so '`foo`', '(bar)'
      = NameAnn {
          NameAnn -> NameAdornment
    nann_adornment :: NameAdornment,
          NameAnn -> EpaLocation
    nann_name      :: EpaLocation,
          NameAnn -> [TrailingAnn]
    nann_trailing  :: [TrailingAnn]
          }
      -- | Used for @(,,,)@, or @(#,,,#)@
      | NameAnnCommas {
          nann_adornment :: NameAdornment,
          NameAnn -> [EpToken ","]
    nann_commas    :: [EpToken ","],
          nann_trailing  :: [TrailingAnn]
          }
      -- | Used for @(# | | #)@
      | NameAnnBars {
          NameAnn -> (EpToken "(#", EpToken "#)")
    nann_parensh   :: (EpToken "(#", EpToken "#)"),
          NameAnn -> [EpToken "|"]
    nann_bars      :: [EpToken "|"],
          nann_trailing  :: [TrailingAnn]
          }
      -- | Used for @()@, @(##)@, @[]@
      | NameAnnOnly {
          nann_adornment :: NameAdornment,
          nann_trailing  :: [TrailingAnn]
          }
      -- | Used for @->@, as an identifier
      | NameAnnRArrow {
          NameAnn -> Maybe (EpToken "(")
    nann_mopen     :: Maybe (EpToken "("),
          NameAnn -> TokRarrow
    nann_arrow     :: TokRarrow,
          NameAnn -> Maybe (EpToken ")")
    nann_mclose    :: Maybe (EpToken ")"),
          nann_trailing  :: [TrailingAnn]
          }
      -- | Used for an item with a leading @'@. The annotation for
      -- unquoted item is stored in 'nann_quoted'.
      | NameAnnQuote {
          NameAnn -> EpToken "'"
    nann_quote     :: EpToken "'",
          NameAnn -> SrcSpanAnnN
    nann_quoted    :: SrcSpanAnnN,
          nann_trailing  :: [TrailingAnn]
          }
      -- | Used when adding a 'TrailingAnn' to an existing 'LocatedN'
      -- which has no Api Annotation.
      | NameAnnTrailing {
          nann_trailing  :: [TrailingAnn]
          }
      deriving (Typeable NameAnn
    Typeable NameAnn =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> NameAnn -> c NameAnn)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NameAnn)
    -> (NameAnn -> Constr)
    -> (NameAnn -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NameAnn))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAnn))
    -> ((forall b. Data b => b -> b) -> NameAnn -> NameAnn)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NameAnn -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NameAnn -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NameAnn -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> NameAnn -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn)
    -> Data NameAnn
    NameAnn -> Constr
    NameAnn -> DataType
    (forall b. Data b => b -> b) -> NameAnn -> NameAnn
    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) -> NameAnn -> u
    forall u. (forall d. Data d => d -> u) -> NameAnn -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAnn -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAnn -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameAnn
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameAnn -> c NameAnn
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameAnn)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAnn)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameAnn -> c NameAnn
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameAnn -> c NameAnn
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameAnn
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameAnn
    $ctoConstr :: NameAnn -> Constr
    toConstr :: NameAnn -> Constr
    $cdataTypeOf :: NameAnn -> DataType
    dataTypeOf :: NameAnn -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameAnn)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameAnn)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAnn)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAnn)
    $cgmapT :: (forall b. Data b => b -> b) -> NameAnn -> NameAnn
    gmapT :: (forall b. Data b => b -> b) -> NameAnn -> NameAnn
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAnn -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAnn -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAnn -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAnn -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameAnn -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NameAnn -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameAnn -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameAnn -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn
    Data, NameAnn -> NameAnn -> Bool
    (NameAnn -> NameAnn -> Bool)
    -> (NameAnn -> NameAnn -> Bool) -> Eq NameAnn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NameAnn -> NameAnn -> Bool
    == :: NameAnn -> NameAnn -> Bool
    $c/= :: NameAnn -> NameAnn -> Bool
    /= :: NameAnn -> NameAnn -> Bool
    Eq)

    -- | A 'NameAnn' can capture the locations of surrounding adornments,
    -- such as parens or backquotes. This data type identifies what
    -- particular pair are being used.
    data NameAdornment
      = NameParens     (EpToken "(")  (EpToken ")")
      | NameParensHash (EpToken "(#") (EpToken "#)")
      | NameBackquotes (EpToken "`")  (EpToken "`")
      | NameSquare     (EpToken "[")  (EpToken "]")
      | NameNoAdornment
      deriving (NameAdornment -> NameAdornment -> Bool
    (NameAdornment -> NameAdornment -> Bool)
    -> (NameAdornment -> NameAdornment -> Bool) -> Eq NameAdornment
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NameAdornment -> NameAdornment -> Bool
    == :: NameAdornment -> NameAdornment -> Bool
    $c/= :: NameAdornment -> NameAdornment -> Bool
    /= :: NameAdornment -> NameAdornment -> Bool
    Eq, Typeable NameAdornment
    Typeable NameAdornment =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> NameAdornment -> c NameAdornment)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NameAdornment)
    -> (NameAdornment -> Constr)
    -> (NameAdornment -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NameAdornment))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c NameAdornment))
    -> ((forall b. Data b => b -> b) -> NameAdornment -> NameAdornment)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NameAdornment -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> NameAdornment -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment)
    -> Data NameAdornment
    NameAdornment -> Constr
    NameAdornment -> DataType
    (forall b. Data b => b -> b) -> NameAdornment -> NameAdornment
    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) -> NameAdornment -> u
    forall u. (forall d. Data d => d -> u) -> NameAdornment -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameAdornment
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameAdornment -> c NameAdornment
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameAdornment)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameAdornment)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameAdornment -> c NameAdornment
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameAdornment -> c NameAdornment
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameAdornment
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameAdornment
    $ctoConstr :: NameAdornment -> Constr
    toConstr :: NameAdornment -> Constr
    $cdataTypeOf :: NameAdornment -> DataType
    dataTypeOf :: NameAdornment -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameAdornment)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameAdornment)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameAdornment)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameAdornment)
    $cgmapT :: (forall b. Data b => b -> b) -> NameAdornment -> NameAdornment
    gmapT :: (forall b. Data b => b -> b) -> NameAdornment -> NameAdornment
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameAdornment -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NameAdornment -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameAdornment -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameAdornment -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment
    Data)

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

    -- | exact print annotation used for capturing the locations of
    -- annotations in pragmas.
    data AnnPragma
      = AnnPragma {
          AnnPragma -> EpaLocation
    apr_open      :: EpaLocation,
          AnnPragma -> EpToken "#-}"
    apr_close     :: EpToken "#-}",
          AnnPragma -> (EpToken "[", EpToken "]")
    apr_squares   :: (EpToken "[", EpToken "]"),
          AnnPragma -> EpaLocation
    apr_loc1      :: EpaLocation,
          AnnPragma -> EpaLocation
    apr_loc2      :: EpaLocation,
          AnnPragma -> EpToken "type"
    apr_type      :: EpToken "type",
          AnnPragma -> EpToken "module"
    apr_module    :: EpToken "module"
          } deriving (Typeable AnnPragma
    Typeable AnnPragma =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnPragma -> c AnnPragma)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c AnnPragma)
    -> (AnnPragma -> Constr)
    -> (AnnPragma -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c AnnPragma))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnPragma))
    -> ((forall b. Data b => b -> b) -> AnnPragma -> AnnPragma)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r)
    -> (forall u. (forall d. Data d => d -> u) -> AnnPragma -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnPragma -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma)
    -> Data AnnPragma
    AnnPragma -> Constr
    AnnPragma -> DataType
    (forall b. Data b => b -> b) -> AnnPragma -> AnnPragma
    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) -> AnnPragma -> u
    forall u. (forall d. Data d => d -> u) -> AnnPragma -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnPragma
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnPragma -> c AnnPragma
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnPragma)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnPragma)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnPragma -> c AnnPragma
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnPragma -> c AnnPragma
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnPragma
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AnnPragma
    $ctoConstr :: AnnPragma -> Constr
    toConstr :: AnnPragma -> Constr
    $cdataTypeOf :: AnnPragma -> DataType
    dataTypeOf :: AnnPragma -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnPragma)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AnnPragma)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnPragma)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnPragma)
    $cgmapT :: (forall b. Data b => b -> b) -> AnnPragma -> AnnPragma
    gmapT :: (forall b. Data b => b -> b) -> AnnPragma -> AnnPragma
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnPragma -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnPragma -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnPragma -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnPragma -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma
    Data,AnnPragma -> AnnPragma -> Bool
    (AnnPragma -> AnnPragma -> Bool)
    -> (AnnPragma -> AnnPragma -> Bool) -> Eq AnnPragma
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AnnPragma -> AnnPragma -> Bool
    == :: AnnPragma -> AnnPragma -> Bool
    $c/= :: AnnPragma -> AnnPragma -> Bool
    /= :: AnnPragma -> AnnPragma -> Bool
    Eq)

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

    -- | Captures the sort order of sub elements for `ValBinds`,
    -- `ClassDecl`, `ClsInstDecl`
    data AnnSortKey tag
      -- See Note [AnnSortKey] below
      = NoAnnSortKey
      | AnnSortKey [tag]
      deriving (Typeable (AnnSortKey tag)
    Typeable (AnnSortKey tag) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> AnnSortKey tag -> c (AnnSortKey tag))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (AnnSortKey tag))
    -> (AnnSortKey tag -> Constr)
    -> (AnnSortKey tag -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (AnnSortKey tag)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (AnnSortKey tag)))
    -> ((forall b. Data b => b -> b)
        -> AnnSortKey tag -> AnnSortKey tag)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> AnnSortKey tag -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> AnnSortKey tag -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> AnnSortKey tag -> m (AnnSortKey tag))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnSortKey tag -> m (AnnSortKey tag))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> AnnSortKey tag -> m (AnnSortKey tag))
    -> Data (AnnSortKey tag)
    AnnSortKey tag -> Constr
    AnnSortKey tag -> DataType
    (forall b. Data b => b -> b) -> AnnSortKey tag -> AnnSortKey tag
    forall tag. Data tag => Typeable (AnnSortKey tag)
    forall tag. Data tag => AnnSortKey tag -> Constr
    forall tag. Data tag => AnnSortKey tag -> DataType
    forall tag.
    Data tag =>
    (forall b. Data b => b -> b) -> AnnSortKey tag -> AnnSortKey tag
    forall tag u.
    Data tag =>
    Int -> (forall d. Data d => d -> u) -> AnnSortKey tag -> u
    forall tag u.
    Data tag =>
    (forall d. Data d => d -> u) -> AnnSortKey tag -> [u]
    forall tag r r'.
    Data tag =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    forall tag r r'.
    Data tag =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    forall tag (m :: * -> *).
    (Data tag, Monad m) =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    forall tag (m :: * -> *).
    (Data tag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    forall tag (c :: * -> *).
    Data tag =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnSortKey tag)
    forall tag (c :: * -> *).
    Data tag =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSortKey tag -> c (AnnSortKey tag)
    forall tag (t :: * -> *) (c :: * -> *).
    (Data tag, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnSortKey tag))
    forall tag (t :: * -> * -> *) (c :: * -> *).
    (Data tag, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnSortKey tag))
    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) -> AnnSortKey tag -> u
    forall u. (forall d. Data d => d -> u) -> AnnSortKey tag -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnSortKey tag)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSortKey tag -> c (AnnSortKey tag)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnSortKey tag))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnSortKey tag))
    $cgfoldl :: forall tag (c :: * -> *).
    Data tag =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSortKey tag -> c (AnnSortKey tag)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AnnSortKey tag -> c (AnnSortKey tag)
    $cgunfold :: forall tag (c :: * -> *).
    Data tag =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnSortKey tag)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AnnSortKey tag)
    $ctoConstr :: forall tag. Data tag => AnnSortKey tag -> Constr
    toConstr :: AnnSortKey tag -> Constr
    $cdataTypeOf :: forall tag. Data tag => AnnSortKey tag -> DataType
    dataTypeOf :: AnnSortKey tag -> DataType
    $cdataCast1 :: forall tag (t :: * -> *) (c :: * -> *).
    (Data tag, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnSortKey tag))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AnnSortKey tag))
    $cdataCast2 :: forall tag (t :: * -> * -> *) (c :: * -> *).
    (Data tag, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnSortKey tag))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (AnnSortKey tag))
    $cgmapT :: forall tag.
    Data tag =>
    (forall b. Data b => b -> b) -> AnnSortKey tag -> AnnSortKey tag
    gmapT :: (forall b. Data b => b -> b) -> AnnSortKey tag -> AnnSortKey tag
    $cgmapQl :: forall tag r r'.
    Data tag =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    $cgmapQr :: forall tag r r'.
    Data tag =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r
    $cgmapQ :: forall tag u.
    Data tag =>
    (forall d. Data d => d -> u) -> AnnSortKey tag -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> AnnSortKey tag -> [u]
    $cgmapQi :: forall tag u.
    Data tag =>
    Int -> (forall d. Data d => d -> u) -> AnnSortKey tag -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> AnnSortKey tag -> u
    $cgmapM :: forall tag (m :: * -> *).
    (Data tag, Monad m) =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    $cgmapMp :: forall tag (m :: * -> *).
    (Data tag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    $cgmapMo :: forall tag (m :: * -> *).
    (Data tag, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AnnSortKey tag -> m (AnnSortKey tag)
    Data, AnnSortKey tag -> AnnSortKey tag -> Bool
    (AnnSortKey tag -> AnnSortKey tag -> Bool)
    -> (AnnSortKey tag -> AnnSortKey tag -> Bool)
    -> Eq (AnnSortKey tag)
    forall tag. Eq tag => AnnSortKey tag -> AnnSortKey tag -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall tag. Eq tag => AnnSortKey tag -> AnnSortKey tag -> Bool
    == :: AnnSortKey tag -> AnnSortKey tag -> Bool
    $c/= :: forall tag. Eq tag => AnnSortKey tag -> AnnSortKey tag -> Bool
    /= :: AnnSortKey tag -> AnnSortKey tag -> Bool
    Eq)

    -- | Used to track of interleaving of binds and signatures for ValBind
    data BindTag
      -- See Note [AnnSortKey] below
      = BindTag
      | SigDTag
      deriving (BindTag -> BindTag -> Bool
    (BindTag -> BindTag -> Bool)
    -> (BindTag -> BindTag -> Bool) -> Eq BindTag
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BindTag -> BindTag -> Bool
    == :: BindTag -> BindTag -> Bool
    $c/= :: BindTag -> BindTag -> Bool
    /= :: BindTag -> BindTag -> Bool
    Eq,Typeable BindTag
    Typeable BindTag =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> BindTag -> c BindTag)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c BindTag)
    -> (BindTag -> Constr)
    -> (BindTag -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c BindTag))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindTag))
    -> ((forall b. Data b => b -> b) -> BindTag -> BindTag)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BindTag -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BindTag -> r)
    -> (forall u. (forall d. Data d => d -> u) -> BindTag -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> BindTag -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> BindTag -> m BindTag)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BindTag -> m BindTag)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BindTag -> m BindTag)
    -> Data BindTag
    BindTag -> Constr
    BindTag -> DataType
    (forall b. Data b => b -> b) -> BindTag -> BindTag
    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) -> BindTag -> u
    forall u. (forall d. Data d => d -> u) -> BindTag -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindTag -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindTag -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindTag
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BindTag -> c BindTag
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindTag)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindTag)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BindTag -> c BindTag
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BindTag -> c BindTag
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindTag
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindTag
    $ctoConstr :: BindTag -> Constr
    toConstr :: BindTag -> Constr
    $cdataTypeOf :: BindTag -> DataType
    dataTypeOf :: BindTag -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindTag)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindTag)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindTag)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindTag)
    $cgmapT :: (forall b. Data b => b -> b) -> BindTag -> BindTag
    gmapT :: (forall b. Data b => b -> b) -> BindTag -> BindTag
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindTag -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindTag -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindTag -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindTag -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> BindTag -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BindTag -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BindTag -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BindTag -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BindTag -> m BindTag
    Data,Eq BindTag
    Eq BindTag =>
    (BindTag -> BindTag -> Ordering)
    -> (BindTag -> BindTag -> Bool)
    -> (BindTag -> BindTag -> Bool)
    -> (BindTag -> BindTag -> Bool)
    -> (BindTag -> BindTag -> Bool)
    -> (BindTag -> BindTag -> BindTag)
    -> (BindTag -> BindTag -> BindTag)
    -> Ord BindTag
    BindTag -> BindTag -> Bool
    BindTag -> BindTag -> Ordering
    BindTag -> BindTag -> BindTag
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: BindTag -> BindTag -> Ordering
    compare :: BindTag -> BindTag -> Ordering
    $c< :: BindTag -> BindTag -> Bool
    < :: BindTag -> BindTag -> Bool
    $c<= :: BindTag -> BindTag -> Bool
    <= :: BindTag -> BindTag -> Bool
    $c> :: BindTag -> BindTag -> Bool
    > :: BindTag -> BindTag -> Bool
    $c>= :: BindTag -> BindTag -> Bool
    >= :: BindTag -> BindTag -> Bool
    $cmax :: BindTag -> BindTag -> BindTag
    max :: BindTag -> BindTag -> BindTag
    $cmin :: BindTag -> BindTag -> BindTag
    min :: BindTag -> BindTag -> BindTag
    Ord,Int -> BindTag -> ShowS
    [BindTag] -> ShowS
    BindTag -> String
    (Int -> BindTag -> ShowS)
    -> (BindTag -> String) -> ([BindTag] -> ShowS) -> Show BindTag
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BindTag -> ShowS
    showsPrec :: Int -> BindTag -> ShowS
    $cshow :: BindTag -> String
    show :: BindTag -> String
    $cshowList :: [BindTag] -> ShowS
    showList :: [BindTag] -> ShowS
    Show)

    -- | Used to track interleaving of class methods, class signatures,
    -- associated types and associate type defaults in `ClassDecl` and
    -- `ClsInstDecl`.
    data DeclTag
      -- See Note [AnnSortKey] below
      = ClsMethodTag
      | ClsSigTag
      | ClsAtTag
      | ClsAtdTag
      deriving (DeclTag -> DeclTag -> Bool
    (DeclTag -> DeclTag -> Bool)
    -> (DeclTag -> DeclTag -> Bool) -> Eq DeclTag
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DeclTag -> DeclTag -> Bool
    == :: DeclTag -> DeclTag -> Bool
    $c/= :: DeclTag -> DeclTag -> Bool
    /= :: DeclTag -> DeclTag -> Bool
    Eq,Typeable DeclTag
    Typeable DeclTag =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DeclTag -> c DeclTag)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DeclTag)
    -> (DeclTag -> Constr)
    -> (DeclTag -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DeclTag))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclTag))
    -> ((forall b. Data b => b -> b) -> DeclTag -> DeclTag)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DeclTag -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DeclTag -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DeclTag -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DeclTag -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag)
    -> Data DeclTag
    DeclTag -> Constr
    DeclTag -> DataType
    (forall b. Data b => b -> b) -> DeclTag -> DeclTag
    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) -> DeclTag -> u
    forall u. (forall d. Data d => d -> u) -> DeclTag -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclTag -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclTag -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeclTag
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclTag -> c DeclTag
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeclTag)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclTag)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclTag -> c DeclTag
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeclTag -> c DeclTag
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeclTag
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeclTag
    $ctoConstr :: DeclTag -> Constr
    toConstr :: DeclTag -> Constr
    $cdataTypeOf :: DeclTag -> DataType
    dataTypeOf :: DeclTag -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeclTag)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeclTag)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclTag)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclTag)
    $cgmapT :: (forall b. Data b => b -> b) -> DeclTag -> DeclTag
    gmapT :: (forall b. Data b => b -> b) -> DeclTag -> DeclTag
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclTag -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclTag -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclTag -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeclTag -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DeclTag -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DeclTag -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeclTag -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeclTag -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag
    Data,Eq DeclTag
    Eq DeclTag =>
    (DeclTag -> DeclTag -> Ordering)
    -> (DeclTag -> DeclTag -> Bool)
    -> (DeclTag -> DeclTag -> Bool)
    -> (DeclTag -> DeclTag -> Bool)
    -> (DeclTag -> DeclTag -> Bool)
    -> (DeclTag -> DeclTag -> DeclTag)
    -> (DeclTag -> DeclTag -> DeclTag)
    -> Ord DeclTag
    DeclTag -> DeclTag -> Bool
    DeclTag -> DeclTag -> Ordering
    DeclTag -> DeclTag -> DeclTag
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: DeclTag -> DeclTag -> Ordering
    compare :: DeclTag -> DeclTag -> Ordering
    $c< :: DeclTag -> DeclTag -> Bool
    < :: DeclTag -> DeclTag -> Bool
    $c<= :: DeclTag -> DeclTag -> Bool
    <= :: DeclTag -> DeclTag -> Bool
    $c> :: DeclTag -> DeclTag -> Bool
    > :: DeclTag -> DeclTag -> Bool
    $c>= :: DeclTag -> DeclTag -> Bool
    >= :: DeclTag -> DeclTag -> Bool
    $cmax :: DeclTag -> DeclTag -> DeclTag
    max :: DeclTag -> DeclTag -> DeclTag
    $cmin :: DeclTag -> DeclTag -> DeclTag
    min :: DeclTag -> DeclTag -> DeclTag
    Ord,Int -> DeclTag -> ShowS
    [DeclTag] -> ShowS
    DeclTag -> String
    (Int -> DeclTag -> ShowS)
    -> (DeclTag -> String) -> ([DeclTag] -> ShowS) -> Show DeclTag
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DeclTag -> ShowS
    showsPrec :: Int -> DeclTag -> ShowS
    $cshow :: DeclTag -> String
    show :: DeclTag -> String
    $cshowList :: [DeclTag] -> ShowS
    showList :: [DeclTag] -> ShowS
    Show)

    {-
    Note [AnnSortKey]
    ~~~~~~~~~~~~~~~~~

    For some constructs in the ParsedSource we have mixed lists of items
    that can be freely intermingled.

    An example is the binds in a where clause, captured in

        ValBinds
            (XValBinds idL idR)
            (LHsBindsLR idL idR) [LSig idR]

    This keeps separate ordered collections of LHsBind GhcPs and LSig GhcPs.

    But there is no constraint on the original source code as to how these
    should appear, so they can have all the signatures first, then their
    binds, or grouped with a signature preceding each bind.

       fa :: Int
       fa = 1

       fb :: Char
       fb = 'c'

    Or

       fa :: Int
       fb :: Char

       fb = 'c'
       fa = 1

    When exact printing these, we need to restore the original order. As
    initially parsed we have the SrcSpan, and can sort on those. But if we
    have modified the AST prior to printing, we cannot rely on the
    SrcSpans for order any more.

    The bag of LHsBind GhcPs is physically ordered, as is the list of LSig
    GhcPs. So in effect we have a list of binds in the order we care
    about, and a list of sigs in the order we care about. The only problem
    is to know how to merge the lists.

    This is where AnnSortKey comes in, which we store in the TTG extension
    point for ValBinds.

        data AnnSortKey tag
          = NoAnnSortKey
          | AnnSortKey [tag]

    When originally parsed, with SrcSpans we can rely on, we do not need
    any extra information, so we tag it with NoAnnSortKey.

    If the binds and signatures are updated in any way, such that we can
    no longer rely on their SrcSpans (e.g. they are copied from elsewhere,
    parsed from scratch for insertion, have a fake SrcSpan), we use
    `AnnSortKey [BindTag]` to keep track.

        data BindTag
          = BindTag
          | SigDTag

    We use it as a merge selector, and have one entry for each bind and
    signature.

    So for the first example we have

      binds: fa = 1 , fb = 'c'
      sigs:  fa :: Int, fb :: Char
      tags: SigDTag, BindTag, SigDTag, BindTag

    so we draw first from the signatures, then the binds, and same again.

    For the second example we have

      binds: fb = 'c', fa = 1
      sigs:  fa :: Int, fb :: Char
      tags: SigDTag, SigDTag, BindTag, BindTag

    so we draw two signatures, then two binds.

    We do similar for ClassDecl and ClsInstDecl, but we have four
    different lists we must manage. For this we use DeclTag.

    -}

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

    -- | Helper function used in the parser to add a 'TrailingAnn' items
    -- to an existing annotation.
    addTrailingAnnToL :: TrailingAnn -> EpAnnComments
                      -> EpAnn (AnnList a) -> EpAnn (AnnList a)
    addTrailingAnnToL :: forall a.
    TrailingAnn
    -> EpAnnComments -> EpAnn (AnnList a) -> EpAnn (AnnList a)
    addTrailingAnnToL TrailingAnn
    t EpAnnComments
    cs EpAnn (AnnList a)
    n = EpAnn (AnnList a)
    n { anns = addTrailing (anns n)
                                   , comments = comments n <> cs }
      where
        -- See Note [list append in addTrailing*]
        addTrailing :: AnnList a -> AnnList a
    addTrailing AnnList a
    n = AnnList a
    n { al_trailing = al_trailing n ++ [t]}

    -- | Helper function used in the parser to add a 'TrailingAnn' items
    -- to an existing annotation.
    addTrailingAnnToA :: TrailingAnn -> EpAnnComments
                      -> EpAnn AnnListItem -> EpAnn AnnListItem
    addTrailingAnnToA :: TrailingAnn
    -> EpAnnComments -> EpAnn AnnListItem -> EpAnn AnnListItem
    addTrailingAnnToA TrailingAnn
    t EpAnnComments
    cs EpAnn AnnListItem
    n = EpAnn AnnListItem
    n { anns = addTrailing (anns n)
                                   , comments = comments n <> cs }
      where
        -- See Note [list append in addTrailing*]
        addTrailing :: AnnListItem -> AnnListItem
    addTrailing AnnListItem
    n = AnnListItem
    n { lann_trailing = lann_trailing n ++ [t] }

    -- | Helper function used in the parser to add a comma location to an
    -- existing annotation.
    addTrailingCommaToN :: EpAnn NameAnn -> EpaLocation -> EpAnn NameAnn
    addTrailingCommaToN :: SrcSpanAnnN -> EpaLocation -> SrcSpanAnnN
    addTrailingCommaToN  SrcSpanAnnN
    n EpaLocation
    l = SrcSpanAnnN
    n { anns = addTrailing (anns n) l }
      where
        -- See Note [list append in addTrailing*]
        addTrailing :: NameAnn -> EpaLocation -> NameAnn
        addTrailing :: NameAnn -> EpaLocation -> NameAnn
    addTrailing NameAnn
    n EpaLocation
    l = NameAnn
    n { nann_trailing = nann_trailing n ++ [AddCommaAnn (EpTok l)]}

    noTrailingN :: SrcSpanAnnN -> SrcSpanAnnN
    noTrailingN :: SrcSpanAnnN -> SrcSpanAnnN
    noTrailingN SrcSpanAnnN
    s = SrcSpanAnnN
    s { anns = (anns s) { nann_trailing = [] } }

    {-
    Note [list append in addTrailing*]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The addTrailingAnnToL, addTrailingAnnToA and addTrailingCommaToN
    functions are used to add a separator for an item when it occurs in a
    list.  So they are used to capture a comma, vbar, semicolon and similar.

    In general, a given element will have zero or one of these.  In
    extreme (test) cases, there may be multiple semicolons.

    In exact printing we sometimes convert the EpaLocation variant for an
    trailing annotation to the EpaDelta variant, which cannot be sorted.

    Hence it is critical that these annotations are captured in the order
    they appear in the original source file.

    And so we use the less efficient list append to preserve the order,
    knowing that in most cases the original list is empty.
    -}

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

    -- |Helper function for converting annotation types.
    --  Discards any annotations
    l2l :: (HasLoc a, HasAnnotation b) => a -> b
    l2l :: forall a b. (HasLoc a, HasAnnotation b) => a -> b
    l2l a
    a = SrcSpan -> b
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan (a -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc a
    a)

    -- |Helper function for converting annotation types.
    --  Discards any annotations
    la2la :: (HasLoc l, HasAnnotation l2) => GenLocated l a -> GenLocated l2 a
    la2la :: forall l l2 a.
    (HasLoc l, HasAnnotation l2) =>
    GenLocated l a -> GenLocated l2 a
    la2la (L l
    la a
    a) = l2 -> a -> GenLocated l2 a
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> l2
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan (l -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc l
    la)) a
    a

    locA :: (HasLoc a) => a -> SrcSpan
    locA :: forall a. HasLoc a => a -> SrcSpan
    locA = a -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc

    reLoc :: (HasLoc (GenLocated a e), HasAnnotation b)
          => GenLocated a e -> GenLocated b e
    reLoc :: forall a e b.
    (HasLoc (GenLocated a e), HasAnnotation b) =>
    GenLocated a e -> GenLocated b e
    reLoc (L a
    la e
    a) = b -> e -> GenLocated b e
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> b
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan (SrcSpan -> b) -> SrcSpan -> b
    forall a b. (a -> b) -> a -> b
    $ GenLocated a e -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA (a -> e -> GenLocated a e
    forall l e. l -> e -> GenLocated l e
    L a
    la e
    a) ) e
    a

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

    class HasAnnotation e where
      noAnnSrcSpan :: SrcSpan -> e

    instance HasAnnotation SrcSpan where
      noAnnSrcSpan :: SrcSpan -> SrcSpan
    noAnnSrcSpan SrcSpan
    l = SrcSpan
    l

    instance HasAnnotation EpaLocation where
      noAnnSrcSpan :: SrcSpan -> EpaLocation
    noAnnSrcSpan SrcSpan
    l = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    l

    instance (NoAnn ann) => HasAnnotation (EpAnn ann) where
      noAnnSrcSpan :: SrcSpan -> EpAnn ann
    noAnnSrcSpan SrcSpan
    l = EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn (SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    spanAsAnchor SrcSpan
    l) ann
    forall a. NoAnn a => a
    noAnn EpAnnComments
    emptyComments

    noLocA :: (HasAnnotation e) => a -> GenLocated e a
    noLocA :: forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA = e -> a -> GenLocated e a
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> e
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan SrcSpan
    noSrcSpan)

    getLocA :: (HasLoc a) => GenLocated a e -> SrcSpan
    getLocA :: forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA = GenLocated a e -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc

    noSrcSpanA :: (HasAnnotation e) => e
    noSrcSpanA :: forall e. HasAnnotation e => e
    noSrcSpanA = SrcSpan -> e
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan SrcSpan
    noSrcSpan

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

    class NoAnn a where
      -- | equivalent of `mempty`, but does not need Semigroup
      noAnn :: a

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

    class HasLoc a where
      -- ^ conveniently calculate locations for things without locations attached
      getHasLoc :: a -> SrcSpan

    instance (HasLoc l) => HasLoc (GenLocated l a) where
      getHasLoc :: GenLocated l a -> SrcSpan
    getHasLoc (L l
    l a
    _) = l -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc l
    l

    instance HasLoc SrcSpan where
      getHasLoc :: SrcSpan -> SrcSpan
    getHasLoc SrcSpan
    l = SrcSpan
    l

    instance (HasLoc a) => (HasLoc (Maybe a)) where
      getHasLoc :: Maybe a -> SrcSpan
    getHasLoc (Just a
    a) = a -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc a
    a
      getHasLoc Maybe a
    Nothing = SrcSpan
    noSrcSpan

    instance HasLoc (EpAnn a) where
      getHasLoc :: EpAnn a -> SrcSpan
    getHasLoc (EpAnn EpaLocation
    l a
    _ EpAnnComments
    _) = EpaLocation -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc EpaLocation
    l

    instance HasLoc EpaLocation where
      getHasLoc :: EpaLocation -> SrcSpan
    getHasLoc (EpaSpan SrcSpan
    l) = SrcSpan
    l
      getHasLoc (EpaDelta SrcSpan
    l DeltaPos
    _ [LEpaComment]
    _) = SrcSpan
    l

    instance HasLoc (EpToken tok) where
      getHasLoc :: EpToken tok -> SrcSpan
    getHasLoc = EpToken tok -> SrcSpan
    forall (tok :: Symbol). EpToken tok -> SrcSpan
    getEpTokenSrcSpan

    instance HasLoc (EpUniToken tok utok) where
      getHasLoc :: EpUniToken tok utok -> SrcSpan
    getHasLoc EpUniToken tok utok
    NoEpUniTok = SrcSpan
    noSrcSpan
      getHasLoc (EpUniTok EpaLocation
    l IsUnicodeSyntax
    _) = EpaLocation -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc EpaLocation
    l

    getHasLocList :: HasLoc a => [a] -> SrcSpan
    getHasLocList :: forall a. HasLoc a => [a] -> SrcSpan
    getHasLocList [] = SrcSpan
    noSrcSpan
    getHasLocList [a]
    xs = (SrcSpan -> SrcSpan -> SrcSpan) -> [SrcSpan] -> SrcSpan
    forall a. HasCallStack => (a -> a -> a) -> [a] -> a
    foldl1' SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans ([SrcSpan] -> SrcSpan) -> [SrcSpan] -> SrcSpan
    forall a b. (a -> b) -> a -> b
    $ (a -> SrcSpan) -> [a] -> [SrcSpan]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc [a]
    xs

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

    realSrcSpan :: SrcSpan -> RealSrcSpan
    realSrcSpan :: SrcSpan -> RealSrcSpan
    realSrcSpan (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    _) = RealSrcSpan
    s
    realSrcSpan SrcSpan
    _ = RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan RealSrcLoc
    l RealSrcLoc
    l -- AZ temporary
      where
        l :: RealSrcLoc
    l = FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc (String -> FastString
    fsLit String
    "realSrcSpan") (-Int
    1) (-Int
    1)

    srcSpan2e :: SrcSpan -> EpaLocation
    srcSpan2e :: SrcSpan -> EpaLocation
    srcSpan2e ss :: SrcSpan
    ss@(RealSrcSpan RealSrcSpan
    _ Maybe BufSpan
    _) = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    ss
    srcSpan2e SrcSpan
    span = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (SrcSpan -> RealSrcSpan
    realSrcSpan SrcSpan
    span) Maybe BufSpan
    forall a. Maybe a
    Strict.Nothing)

    reAnnC :: AnnContext -> EpAnnComments -> Located a -> LocatedC a
    reAnnC :: forall a. AnnContext -> EpAnnComments -> Located a -> LocatedC a
    reAnnC AnnContext
    anns EpAnnComments
    cs (L SrcSpan
    l a
    a) = SrcSpanAnnC -> a -> GenLocated SrcSpanAnnC a
    forall l e. l -> e -> GenLocated l e
    L (EpaLocation -> AnnContext -> EpAnnComments -> SrcSpanAnnC
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn (SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    spanAsAnchor SrcSpan
    l) AnnContext
    anns EpAnnComments
    cs) a
    a

    reAnnL :: ann -> EpAnnComments -> Located e -> GenLocated (EpAnn ann) e
    reAnnL :: forall ann e.
    ann -> EpAnnComments -> Located e -> GenLocated (EpAnn ann) e
    reAnnL ann
    anns EpAnnComments
    cs (L SrcSpan
    l e
    a) = EpAnn ann -> e -> GenLocated (EpAnn ann) e
    forall l e. l -> e -> GenLocated l e
    L (EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn (SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    spanAsAnchor SrcSpan
    l) ann
    anns EpAnnComments
    cs) e
    a

    getLocAnn :: Located a  -> SrcSpanAnnA
    getLocAnn :: forall a. Located a -> EpAnn AnnListItem
    getLocAnn (L SrcSpan
    l a
    _) = SrcSpan -> EpAnn AnnListItem
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan SrcSpan
    l

    -- AZ:TODO use widenSpan here too
    addAnnsA :: SrcSpanAnnA -> [TrailingAnn] -> EpAnnComments -> SrcSpanAnnA
    addAnnsA :: EpAnn AnnListItem
    -> [TrailingAnn] -> EpAnnComments -> EpAnn AnnListItem
    addAnnsA (EpAnn EpaLocation
    l AnnListItem
    as1 EpAnnComments
    cs) [TrailingAnn]
    as2 EpAnnComments
    cs2
      = EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    l ([TrailingAnn] -> AnnListItem
    AnnListItem (AnnListItem -> [TrailingAnn]
    lann_trailing AnnListItem
    as1 [TrailingAnn] -> [TrailingAnn] -> [TrailingAnn]
    forall a. [a] -> [a] -> [a]
    ++ [TrailingAnn]
    as2)) (EpAnnComments
    cs EpAnnComments -> EpAnnComments -> EpAnnComments
    forall a. Semigroup a => a -> a -> a
    <> EpAnnComments
    cs2)

    -- | The annotations need to all come after the anchor.  Make sure
    -- this is the case.
    widenSpanL :: SrcSpan -> [EpaLocation] -> SrcSpan
    widenSpanL :: SrcSpan -> [EpaLocation] -> SrcSpan
    widenSpanL SrcSpan
    s [EpaLocation]
    as = (SrcSpan -> SrcSpan -> SrcSpan) -> SrcSpan -> [SrcSpan] -> SrcSpan
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans SrcSpan
    s ([EpaLocation] -> [SrcSpan]
    forall {a}. [EpaLocation' a] -> [SrcSpan]
    go [EpaLocation]
    as)
      where
        go :: [EpaLocation' a] -> [SrcSpan]
    go [] = []
        go ((EpaSpan (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    mb):[EpaLocation' a]
    rest)) = RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    mb SrcSpan -> [SrcSpan] -> [SrcSpan]
    forall a. a -> [a] -> [a]
    : [EpaLocation' a] -> [SrcSpan]
    go [EpaLocation' a]
    rest
        go ((EpaSpan SrcSpan
    _):[EpaLocation' a]
    rest) = [EpaLocation' a] -> [SrcSpan]
    go [EpaLocation' a]
    rest
        go ((EpaDelta SrcSpan
    _ DeltaPos
    _ a
    _):[EpaLocation' a]
    rest) = [EpaLocation' a] -> [SrcSpan]
    go [EpaLocation' a]
    rest

    widenSpanT :: SrcSpan -> EpToken tok -> SrcSpan
    widenSpanT :: forall (tok :: Symbol). SrcSpan -> EpToken tok -> SrcSpan
    widenSpanT SrcSpan
    l (EpTok EpaLocation
    loc) = SrcSpan -> [EpaLocation] -> SrcSpan
    widenSpanL SrcSpan
    l [EpaLocation
    loc]
    widenSpanT SrcSpan
    l EpToken tok
    NoEpTok = SrcSpan
    l

    listLocation :: [LocatedAn an a] -> EpaLocation
    listLocation :: forall an a. [LocatedAn an a] -> EpaLocation
    listLocation [LocatedAn an a]
    as = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (SrcSpan -> [LocatedAn an a] -> SrcSpan
    forall {ann} {e}. SrcSpan -> [GenLocated (EpAnn ann) e] -> SrcSpan
    go SrcSpan
    noSrcSpan [LocatedAn an a]
    as)
      where
        combine :: SrcSpan -> SrcSpan -> SrcSpan
    combine SrcSpan
    l SrcSpan
    r = SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans SrcSpan
    l SrcSpan
    r

        go :: SrcSpan -> [GenLocated (EpAnn ann) e] -> SrcSpan
    go SrcSpan
    acc [] = SrcSpan
    acc
        go SrcSpan
    acc (L (EpAnn (EpaSpan SrcSpan
    s) ann
    _ EpAnnComments
    _) e
    _:[GenLocated (EpAnn ann) e]
    rest) = SrcSpan -> [GenLocated (EpAnn ann) e] -> SrcSpan
    go (SrcSpan -> SrcSpan -> SrcSpan
    combine SrcSpan
    acc SrcSpan
    s) [GenLocated (EpAnn ann) e]
    rest
        go SrcSpan
    acc (GenLocated (EpAnn ann) e
    _:[GenLocated (EpAnn ann) e]
    rest) = SrcSpan -> [GenLocated (EpAnn ann) e] -> SrcSpan
    go SrcSpan
    acc [GenLocated (EpAnn ann) e]
    rest

    widenAnchorT :: EpaLocation -> EpToken tok -> EpaLocation
    widenAnchorT :: forall (tok :: Symbol). EpaLocation -> EpToken tok -> EpaLocation
    widenAnchorT (EpaSpan SrcSpan
    ss) (EpTok EpaLocation
    l) = EpaLocation -> SrcSpan -> EpaLocation
    widenAnchorS EpaLocation
    l SrcSpan
    ss
    widenAnchorT EpaLocation
    ss EpToken tok
    _ = EpaLocation
    ss

    widenAnchorS :: EpaLocation -> SrcSpan -> EpaLocation
    widenAnchorS :: EpaLocation -> SrcSpan -> EpaLocation
    widenAnchorS (EpaSpan (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    mbe)) (RealSrcSpan RealSrcSpan
    r Maybe BufSpan
    mbr)
      = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (RealSrcSpan -> RealSrcSpan -> RealSrcSpan
    combineRealSrcSpans RealSrcSpan
    s RealSrcSpan
    r) ((BufSpan -> BufSpan -> BufSpan)
    -> Maybe BufSpan -> Maybe BufSpan -> Maybe BufSpan
    forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 BufSpan -> BufSpan -> BufSpan
    combineBufSpans Maybe BufSpan
    mbe Maybe BufSpan
    mbr))
    widenAnchorS (EpaSpan SrcSpan
    us) SrcSpan
    _ = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    us
    widenAnchorS EpaDelta{} (RealSrcSpan RealSrcSpan
    r Maybe BufSpan
    mb) = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    r Maybe BufSpan
    mb)
    widenAnchorS EpaLocation
    anc SrcSpan
    _ = EpaLocation
    anc

    widenLocatedAnL :: EpAnn an -> [EpaLocation] -> EpAnn an
    widenLocatedAnL :: forall an. EpAnn an -> [EpaLocation] -> EpAnn an
    widenLocatedAnL (EpAnn (EpaSpan SrcSpan
    l) an
    a EpAnnComments
    cs) [EpaLocation]
    as = EpaLocation -> an -> EpAnnComments -> EpAnn an
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn (SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    spanAsAnchor SrcSpan
    l') an
    a EpAnnComments
    cs
      where
        l' :: SrcSpan
    l' = SrcSpan -> [EpaLocation] -> SrcSpan
    widenSpanL SrcSpan
    l [EpaLocation]
    as
    widenLocatedAnL (EpAnn EpaLocation
    anc an
    a EpAnnComments
    cs) [EpaLocation]
    _as = EpaLocation -> an -> EpAnnComments -> EpAnn an
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    anc an
    a EpAnnComments
    cs

    epAnnComments :: EpAnn an -> EpAnnComments
    epAnnComments :: forall ann. EpAnn ann -> EpAnnComments
    epAnnComments (EpAnn EpaLocation
    _ an
    _ EpAnnComments
    cs) = EpAnnComments
    cs

    -- ---------------------------------------------------------------------
    sortLocatedA :: (HasLoc (EpAnn a)) => [GenLocated (EpAnn a) e] -> [GenLocated (EpAnn a) e]
    sortLocatedA :: forall a e.
    HasLoc (EpAnn a) =>
    [GenLocated (EpAnn a) e] -> [GenLocated (EpAnn a) e]
    sortLocatedA = (GenLocated (EpAnn a) e -> GenLocated (EpAnn a) e -> Ordering)
    -> [GenLocated (EpAnn a) e] -> [GenLocated (EpAnn a) e]
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (SrcSpan -> SrcSpan -> Ordering
    leftmost_smallest (SrcSpan -> SrcSpan -> Ordering)
    -> (GenLocated (EpAnn a) e -> SrcSpan)
    -> GenLocated (EpAnn a) e
    -> GenLocated (EpAnn a) e
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` GenLocated (EpAnn a) e -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA)

    mapLocA :: (NoAnn ann) => (a -> b) -> GenLocated SrcSpan a -> GenLocated (EpAnn ann) b
    mapLocA :: forall ann a b.
    NoAnn ann =>
    (a -> b) -> GenLocated SrcSpan a -> GenLocated (EpAnn ann) b
    mapLocA a -> b
    f (L SrcSpan
    l a
    a) = EpAnn ann -> b -> GenLocated (EpAnn ann) b
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> EpAnn ann
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan SrcSpan
    l) (a -> b
    f a
    a)

    -- AZ:TODO: move this somewhere sane
    combineLocsA :: Semigroup a => GenLocated (EpAnn a) e1 -> GenLocated (EpAnn a) e2 -> EpAnn a
    combineLocsA :: forall a e1 e2.
    Semigroup a =>
    GenLocated (EpAnn a) e1 -> GenLocated (EpAnn a) e2 -> EpAnn a
    combineLocsA (L EpAnn a
    a e1
    _) (L EpAnn a
    b e2
    _) = EpAnn a -> EpAnn a -> EpAnn a
    forall a. Semigroup a => EpAnn a -> EpAnn a -> EpAnn a
    combineSrcSpansA EpAnn a
    a EpAnn a
    b

    combineSrcSpansA :: Semigroup a => EpAnn a -> EpAnn a -> EpAnn a
    combineSrcSpansA :: forall a. Semigroup a => EpAnn a -> EpAnn a -> EpAnn a
    combineSrcSpansA EpAnn a
    aa EpAnn a
    ab = EpAnn a
    aa EpAnn a -> EpAnn a -> EpAnn a
    forall a. Semigroup a => a -> a -> a
    <> EpAnn a
    ab

    -- | Combine locations from two 'Located' things and add them to a third thing
    addCLocA :: (HasLoc a, HasLoc b, HasAnnotation l)
             => a -> b -> c -> GenLocated l c
    addCLocA :: forall a b l c.
    (HasLoc a, HasLoc b, HasAnnotation l) =>
    a -> b -> c -> GenLocated l c
    addCLocA a
    a b
    b c
    c = l -> c -> GenLocated l c
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> l
    forall e. HasAnnotation e => SrcSpan -> e
    noAnnSrcSpan (SrcSpan -> l) -> SrcSpan -> l
    forall a b. (a -> b) -> a -> b
    $ SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans (a -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc a
    a) (b -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    getHasLoc b
    b)) c
    c

    -- ---------------------------------------------------------------------
    -- Utilities for manipulating EpAnnComments
    -- ---------------------------------------------------------------------

    getFollowingComments :: EpAnnComments -> [LEpaComment]
    getFollowingComments :: EpAnnComments -> [LEpaComment]
    getFollowingComments (EpaComments [LEpaComment]
    _) = []
    getFollowingComments (EpaCommentsBalanced [LEpaComment]
    _ [LEpaComment]
    cs) = [LEpaComment]
    cs

    setFollowingComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
    setFollowingComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
    setFollowingComments (EpaComments [LEpaComment]
    ls) [LEpaComment]
    cs           = [LEpaComment] -> [LEpaComment] -> EpAnnComments
    EpaCommentsBalanced [LEpaComment]
    ls [LEpaComment]
    cs
    setFollowingComments (EpaCommentsBalanced [LEpaComment]
    ls [LEpaComment]
    _) [LEpaComment]
    cs = [LEpaComment] -> [LEpaComment] -> EpAnnComments
    EpaCommentsBalanced [LEpaComment]
    ls [LEpaComment]
    cs

    setPriorComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
    setPriorComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
    setPriorComments (EpaComments [LEpaComment]
    _) [LEpaComment]
    cs            = [LEpaComment] -> EpAnnComments
    EpaComments [LEpaComment]
    cs
    setPriorComments (EpaCommentsBalanced [LEpaComment]
    _ [LEpaComment]
    ts) [LEpaComment]
    cs = [LEpaComment] -> [LEpaComment] -> EpAnnComments
    EpaCommentsBalanced [LEpaComment]
    cs [LEpaComment]
    ts

    -- ---------------------------------------------------------------------
    -- Comment-only annotations
    -- ---------------------------------------------------------------------

    type EpAnnCO = EpAnn NoEpAnns -- ^ Api Annotations for comments only

    data NoEpAnns = NoEpAnns
      deriving (Typeable NoEpAnns
    Typeable NoEpAnns =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> NoEpAnns -> c NoEpAnns)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NoEpAnns)
    -> (NoEpAnns -> Constr)
    -> (NoEpAnns -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NoEpAnns))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoEpAnns))
    -> ((forall b. Data b => b -> b) -> NoEpAnns -> NoEpAnns)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NoEpAnns -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> NoEpAnns -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns)
    -> Data NoEpAnns
    NoEpAnns -> Constr
    NoEpAnns -> DataType
    (forall b. Data b => b -> b) -> NoEpAnns -> NoEpAnns
    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) -> NoEpAnns -> u
    forall u. (forall d. Data d => d -> u) -> NoEpAnns -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NoEpAnns
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NoEpAnns -> c NoEpAnns
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NoEpAnns)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoEpAnns)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NoEpAnns -> c NoEpAnns
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NoEpAnns -> c NoEpAnns
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NoEpAnns
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NoEpAnns
    $ctoConstr :: NoEpAnns -> Constr
    toConstr :: NoEpAnns -> Constr
    $cdataTypeOf :: NoEpAnns -> DataType
    dataTypeOf :: NoEpAnns -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NoEpAnns)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NoEpAnns)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoEpAnns)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoEpAnns)
    $cgmapT :: (forall b. Data b => b -> b) -> NoEpAnns -> NoEpAnns
    gmapT :: (forall b. Data b => b -> b) -> NoEpAnns -> NoEpAnns
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NoEpAnns -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NoEpAnns -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoEpAnns -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoEpAnns -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns
    Data,NoEpAnns -> NoEpAnns -> Bool
    (NoEpAnns -> NoEpAnns -> Bool)
    -> (NoEpAnns -> NoEpAnns -> Bool) -> Eq NoEpAnns
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NoEpAnns -> NoEpAnns -> Bool
    == :: NoEpAnns -> NoEpAnns -> Bool
    $c/= :: NoEpAnns -> NoEpAnns -> Bool
    /= :: NoEpAnns -> NoEpAnns -> Bool
    Eq,Eq NoEpAnns
    Eq NoEpAnns =>
    (NoEpAnns -> NoEpAnns -> Ordering)
    -> (NoEpAnns -> NoEpAnns -> Bool)
    -> (NoEpAnns -> NoEpAnns -> Bool)
    -> (NoEpAnns -> NoEpAnns -> Bool)
    -> (NoEpAnns -> NoEpAnns -> Bool)
    -> (NoEpAnns -> NoEpAnns -> NoEpAnns)
    -> (NoEpAnns -> NoEpAnns -> NoEpAnns)
    -> Ord NoEpAnns
    NoEpAnns -> NoEpAnns -> Bool
    NoEpAnns -> NoEpAnns -> Ordering
    NoEpAnns -> NoEpAnns -> NoEpAnns
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: NoEpAnns -> NoEpAnns -> Ordering
    compare :: NoEpAnns -> NoEpAnns -> Ordering
    $c< :: NoEpAnns -> NoEpAnns -> Bool
    < :: NoEpAnns -> NoEpAnns -> Bool
    $c<= :: NoEpAnns -> NoEpAnns -> Bool
    <= :: NoEpAnns -> NoEpAnns -> Bool
    $c> :: NoEpAnns -> NoEpAnns -> Bool
    > :: NoEpAnns -> NoEpAnns -> Bool
    $c>= :: NoEpAnns -> NoEpAnns -> Bool
    >= :: NoEpAnns -> NoEpAnns -> Bool
    $cmax :: NoEpAnns -> NoEpAnns -> NoEpAnns
    max :: NoEpAnns -> NoEpAnns -> NoEpAnns
    $cmin :: NoEpAnns -> NoEpAnns -> NoEpAnns
    min :: NoEpAnns -> NoEpAnns -> NoEpAnns
    Ord)

    noComments ::EpAnnCO
    noComments :: EpAnnCO
    noComments = EpaLocation -> NoEpAnns -> EpAnnComments -> EpAnnCO
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    forall a. NoAnn a => EpaLocation' a
    noSpanAnchor NoEpAnns
    NoEpAnns EpAnnComments
    emptyComments

    -- TODO:AZ get rid of this
    placeholderRealSpan :: RealSrcSpan
    placeholderRealSpan :: RealSrcSpan
    placeholderRealSpan = RealSrcLoc -> RealSrcSpan
    realSrcLocSpan (FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc (String -> FastString
    mkFastString String
    "placeholder") (-Int
    1) (-Int
    1))

    comment :: RealSrcSpan -> EpAnnComments -> EpAnnCO
    comment :: RealSrcSpan -> EpAnnComments -> EpAnnCO
    comment RealSrcSpan
    loc EpAnnComments
    cs = EpaLocation -> NoEpAnns -> EpAnnComments -> EpAnnCO
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn (SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    loc Maybe BufSpan
    forall a. Maybe a
    Strict.Nothing)) NoEpAnns
    NoEpAnns EpAnnComments
    cs

    -- ---------------------------------------------------------------------
    -- Utilities for managing comments in an `EpAnn a` structure.
    -- ---------------------------------------------------------------------

    -- | Add additional comments to a 'EpAnn', used for manipulating the
    -- AST prior to exact printing the changed one.
    addCommentsToEpAnn :: (NoAnn ann) => EpAnn ann -> EpAnnComments -> EpAnn ann
    addCommentsToEpAnn :: forall ann. NoAnn ann => EpAnn ann -> EpAnnComments -> EpAnn ann
    addCommentsToEpAnn (EpAnn EpaLocation
    a ann
    an EpAnnComments
    cs) EpAnnComments
    cs' = EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a ann
    an (EpAnnComments
    cs EpAnnComments -> EpAnnComments -> EpAnnComments
    forall a. Semigroup a => a -> a -> a
    <> EpAnnComments
    cs')

    -- | Replace any existing comments on a 'EpAnn', used for manipulating the
    -- AST prior to exact printing the changed one.
    setCommentsEpAnn :: (NoAnn ann) => EpAnn ann -> EpAnnComments -> EpAnn ann
    setCommentsEpAnn :: forall ann. NoAnn ann => EpAnn ann -> EpAnnComments -> EpAnn ann
    setCommentsEpAnn (EpAnn EpaLocation
    a ann
    an EpAnnComments
    _) EpAnnComments
    cs = (EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a ann
    an EpAnnComments
    cs)

    -- | Transfer comments and trailing items from the annotations in the
    -- first 'SrcSpanAnnA' argument to those in the second.
    transferAnnsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA,  SrcSpanAnnA)
    transferAnnsA :: EpAnn AnnListItem
    -> EpAnn AnnListItem -> (EpAnn AnnListItem, EpAnn AnnListItem)
    transferAnnsA (EpAnn EpaLocation
    a AnnListItem
    an EpAnnComments
    cs) (EpAnn EpaLocation
    a' AnnListItem
    an' EpAnnComments
    cs')
      = (EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a AnnListItem
    forall a. NoAnn a => a
    noAnn EpAnnComments
    emptyComments, EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a' (AnnListItem
    an' AnnListItem -> AnnListItem -> AnnListItem
    forall a. Semigroup a => a -> a -> a
    <> AnnListItem
    an) (EpAnnComments
    cs' EpAnnComments -> EpAnnComments -> EpAnnComments
    forall a. Semigroup a => a -> a -> a
    <> EpAnnComments
    cs))

    -- | Transfer trailing items but not comments from the annotations in the
    -- first 'SrcSpanAnnA' argument to those in the second.
    transferFollowingA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA,  SrcSpanAnnA)
    transferFollowingA :: EpAnn AnnListItem
    -> EpAnn AnnListItem -> (EpAnn AnnListItem, EpAnn AnnListItem)
    transferFollowingA (EpAnn EpaLocation
    a1 AnnListItem
    an1 EpAnnComments
    cs1) (EpAnn EpaLocation
    a2 AnnListItem
    an2 EpAnnComments
    cs2)
      = (EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a1 AnnListItem
    forall a. NoAnn a => a
    noAnn EpAnnComments
    cs1', EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a2 (AnnListItem
    an1 AnnListItem -> AnnListItem -> AnnListItem
    forall a. Semigroup a => a -> a -> a
    <> AnnListItem
    an2) EpAnnComments
    cs2')
      where
        pc :: [LEpaComment]
    pc = EpAnnComments -> [LEpaComment]
    priorComments EpAnnComments
    cs1
        fc :: [LEpaComment]
    fc = EpAnnComments -> [LEpaComment]
    getFollowingComments EpAnnComments
    cs1
        cs1' :: EpAnnComments
    cs1' = EpAnnComments -> [LEpaComment] -> EpAnnComments
    setPriorComments EpAnnComments
    emptyComments [LEpaComment]
    pc
        cs2' :: EpAnnComments
    cs2' = EpAnnComments -> [LEpaComment] -> EpAnnComments
    setFollowingComments EpAnnComments
    cs2 [LEpaComment]
    fc

    -- | Transfer trailing items from the annotations in the
    -- first 'SrcSpanAnnA' argument to those in the second.
    transferAnnsOnlyA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA,  SrcSpanAnnA)
    transferAnnsOnlyA :: EpAnn AnnListItem
    -> EpAnn AnnListItem -> (EpAnn AnnListItem, EpAnn AnnListItem)
    transferAnnsOnlyA (EpAnn EpaLocation
    a AnnListItem
    an EpAnnComments
    cs) (EpAnn EpaLocation
    a' AnnListItem
    an' EpAnnComments
    cs')
      = (EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a AnnListItem
    forall a. NoAnn a => a
    noAnn EpAnnComments
    cs, EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a' (AnnListItem
    an' AnnListItem -> AnnListItem -> AnnListItem
    forall a. Semigroup a => a -> a -> a
    <> AnnListItem
    an) EpAnnComments
    cs')

    -- | Transfer comments from the annotations in the
    -- first 'SrcSpanAnnA' argument to those in the second.
    transferCommentsOnlyA :: EpAnn a -> EpAnn b -> (EpAnn a,  EpAnn b)
    transferCommentsOnlyA :: forall a b. EpAnn a -> EpAnn b -> (EpAnn a, EpAnn b)
    transferCommentsOnlyA (EpAnn EpaLocation
    a a
    an EpAnnComments
    cs) (EpAnn EpaLocation
    a' b
    an' EpAnnComments
    cs')
      = (EpaLocation -> a -> EpAnnComments -> EpAnn a
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a a
    an EpAnnComments
    emptyComments, EpaLocation -> b -> EpAnnComments -> EpAnn b
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a' b
    an' (EpAnnComments
    cs EpAnnComments -> EpAnnComments -> EpAnnComments
    forall a. Semigroup a => a -> a -> a
    <> EpAnnComments
    cs'))

    -- | Transfer prior comments only from the annotations in the
    -- first 'SrcSpanAnnA' argument to those in the second.
    transferPriorCommentsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA,  SrcSpanAnnA)
    transferPriorCommentsA :: EpAnn AnnListItem
    -> EpAnn AnnListItem -> (EpAnn AnnListItem, EpAnn AnnListItem)
    transferPriorCommentsA (EpAnn EpaLocation
    a1 AnnListItem
    an1 EpAnnComments
    cs1) (EpAnn EpaLocation
    a2 AnnListItem
    an2 EpAnnComments
    cs2)
      = (EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a1 AnnListItem
    an1 EpAnnComments
    cs1', EpaLocation -> AnnListItem -> EpAnnComments -> EpAnn AnnListItem
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a2 AnnListItem
    an2 EpAnnComments
    cs2')
      where
        pc :: [LEpaComment]
    pc = EpAnnComments -> [LEpaComment]
    priorComments EpAnnComments
    cs1
        fc :: [LEpaComment]
    fc = EpAnnComments -> [LEpaComment]
    getFollowingComments EpAnnComments
    cs1
        cs1' :: EpAnnComments
    cs1' = EpAnnComments -> [LEpaComment] -> EpAnnComments
    setFollowingComments EpAnnComments
    emptyComments [LEpaComment]
    fc
        cs2' :: EpAnnComments
    cs2' = EpAnnComments -> [LEpaComment] -> EpAnnComments
    setPriorComments EpAnnComments
    cs2 (EpAnnComments -> [LEpaComment]
    priorComments EpAnnComments
    cs2 [LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. Semigroup a => a -> a -> a
    <> [LEpaComment]
    pc)

    -- | Remove the exact print annotations payload, leaving only the
    -- anchor and comments.
    commentsOnlyA :: NoAnn ann => EpAnn ann -> EpAnn ann
    commentsOnlyA :: forall ann. NoAnn ann => EpAnn ann -> EpAnn ann
    commentsOnlyA (EpAnn EpaLocation
    a ann
    _ EpAnnComments
    cs) = EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a ann
    forall a. NoAnn a => a
    noAnn EpAnnComments
    cs

    -- | Remove the comments, leaving the exact print annotations payload
    removeCommentsA :: EpAnn ann -> EpAnn ann
    removeCommentsA :: forall ann. EpAnn ann -> EpAnn ann
    removeCommentsA (EpAnn EpaLocation
    a ann
    an EpAnnComments
    _) = EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    a ann
    an EpAnnComments
    emptyComments

    -- ---------------------------------------------------------------------
    -- Semigroup instances, to allow easy combination of annotation elements
    -- ---------------------------------------------------------------------

    instance (Semigroup a) => Semigroup (EpAnn a) where
      (EpAnn EpaLocation
    l1 a
    a1 EpAnnComments
    b1) <> :: EpAnn a -> EpAnn a -> EpAnn a
    <> (EpAnn EpaLocation
    l2 a
    a2 EpAnnComments
    b2) = EpaLocation -> a -> EpAnnComments -> EpAnn a
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn (EpaLocation
    l1 EpaLocation -> EpaLocation -> EpaLocation
    forall a. Semigroup a => a -> a -> a
    <> EpaLocation
    l2) (a
    a1 a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    a2) (EpAnnComments
    b1 EpAnnComments -> EpAnnComments -> EpAnnComments
    forall a. Semigroup a => a -> a -> a
    <> EpAnnComments
    b2)
       -- The critical part about the anchor is its left edge, and all
       -- annotations must follow it. So we combine them which yields the
       -- largest span

    instance Semigroup EpaLocation where
      EpaSpan SrcSpan
    s1       <> :: EpaLocation -> EpaLocation -> EpaLocation
    <> EpaSpan SrcSpan
    s2        = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan (SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans SrcSpan
    s1 SrcSpan
    s2)
      EpaSpan SrcSpan
    s1       <> EpaLocation
    _                 = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    s1
      EpaLocation
    _                <> EpaSpan SrcSpan
    s2        = SrcSpan -> EpaLocation
    forall a. SrcSpan -> EpaLocation' a
    EpaSpan SrcSpan
    s2
      EpaDelta SrcSpan
    s1 DeltaPos
    dp1 [LEpaComment]
    cs1 <> EpaDelta SrcSpan
    s2 DeltaPos
    _dp2 [LEpaComment]
    cs2 = SrcSpan -> DeltaPos -> [LEpaComment] -> EpaLocation
    forall a. SrcSpan -> DeltaPos -> a -> EpaLocation' a
    EpaDelta (SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans SrcSpan
    s1 SrcSpan
    s2) DeltaPos
    dp1 ([LEpaComment]
    cs1[LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. Semigroup a => a -> a -> a
    <>[LEpaComment]
    cs2)

    instance Semigroup EpAnnComments where
      EpaComments [LEpaComment]
    cs1 <> :: EpAnnComments -> EpAnnComments -> EpAnnComments
    <> EpaComments [LEpaComment]
    cs2 = [LEpaComment] -> EpAnnComments
    EpaComments ([LEpaComment]
    cs1 [LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. [a] -> [a] -> [a]
    ++ [LEpaComment]
    cs2)
      EpaComments [LEpaComment]
    cs1 <> EpaCommentsBalanced [LEpaComment]
    cs2 [LEpaComment]
    as2 = [LEpaComment] -> [LEpaComment] -> EpAnnComments
    EpaCommentsBalanced ([LEpaComment]
    cs1 [LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. [a] -> [a] -> [a]
    ++ [LEpaComment]
    cs2) [LEpaComment]
    as2
      EpaCommentsBalanced [LEpaComment]
    cs1 [LEpaComment]
    as1 <> EpaComments [LEpaComment]
    cs2 = [LEpaComment] -> [LEpaComment] -> EpAnnComments
    EpaCommentsBalanced ([LEpaComment]
    cs1 [LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. [a] -> [a] -> [a]
    ++ [LEpaComment]
    cs2) [LEpaComment]
    as1
      EpaCommentsBalanced [LEpaComment]
    cs1 [LEpaComment]
    as1 <> EpaCommentsBalanced [LEpaComment]
    cs2 [LEpaComment]
    as2 = [LEpaComment] -> [LEpaComment] -> EpAnnComments
    EpaCommentsBalanced ([LEpaComment]
    cs1 [LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. [a] -> [a] -> [a]
    ++ [LEpaComment]
    cs2) ([LEpaComment]
    as1[LEpaComment] -> [LEpaComment] -> [LEpaComment]
    forall a. [a] -> [a] -> [a]
    ++[LEpaComment]
    as2)

    instance Semigroup AnnListItem where
      (AnnListItem [TrailingAnn]
    l1) <> :: AnnListItem -> AnnListItem -> AnnListItem
    <> (AnnListItem [TrailingAnn]
    l2) = [TrailingAnn] -> AnnListItem
    AnnListItem ([TrailingAnn]
    l1 [TrailingAnn] -> [TrailingAnn] -> [TrailingAnn]
    forall a. Semigroup a => a -> a -> a
    <> [TrailingAnn]
    l2)

    instance Semigroup (AnnSortKey tag) where
      AnnSortKey tag
    NoAnnSortKey <> :: AnnSortKey tag -> AnnSortKey tag -> AnnSortKey tag
    <> AnnSortKey tag
    x = AnnSortKey tag
    x
      AnnSortKey tag
    x <> AnnSortKey tag
    NoAnnSortKey = AnnSortKey tag
    x
      AnnSortKey [tag]
    ls1 <> AnnSortKey [tag]
    ls2 = [tag] -> AnnSortKey tag
    forall tag. [tag] -> AnnSortKey tag
    AnnSortKey ([tag]
    ls1 [tag] -> [tag] -> [tag]
    forall a. Semigroup a => a -> a -> a
    <> [tag]
    ls2)

    instance Monoid (AnnSortKey tag) where
      mempty :: AnnSortKey tag
    mempty = AnnSortKey tag
    forall tag. AnnSortKey tag
    NoAnnSortKey

    -- ---------------------------------------------------------------------
    -- NoAnn instances
    -- ---------------------------------------------------------------------

    instance NoAnn EpaLocation where
      noAnn :: EpaLocation
    noAnn = SrcSpan -> DeltaPos -> [LEpaComment] -> EpaLocation
    forall a. SrcSpan -> DeltaPos -> a -> EpaLocation' a
    EpaDelta SrcSpan
    noSrcSpan (Int -> DeltaPos
    SameLine Int
    0) []

    instance NoAnn [a] where
      noAnn :: [a]
    noAnn = []

    instance NoAnn (Maybe a) where
      noAnn :: Maybe a
    noAnn = Maybe a
    forall a. Maybe a
    Nothing

    instance NoAnn a => NoAnn (Either a b) where
      noAnn :: Either a b
    noAnn = a -> Either a b
    forall a b. a -> Either a b
    Left a
    forall a. NoAnn a => a
    noAnn

    instance (NoAnn a, NoAnn b) => NoAnn (a, b) where
      noAnn :: (a, b)
    noAnn = (a
    forall a. NoAnn a => a
    noAnn, b
    forall a. NoAnn a => a
    noAnn)

    instance (NoAnn a, NoAnn b, NoAnn c) => NoAnn (a, b, c) where
      noAnn :: (a, b, c)
    noAnn = (a
    forall a. NoAnn a => a
    noAnn, b
    forall a. NoAnn a => a
    noAnn, c
    forall a. NoAnn a => a
    noAnn)

    instance (NoAnn a, NoAnn b, NoAnn c, NoAnn d) => NoAnn (a, b, c, d) where
      noAnn :: (a, b, c, d)
    noAnn = (a
    forall a. NoAnn a => a
    noAnn, b
    forall a. NoAnn a => a
    noAnn, c
    forall a. NoAnn a => a
    noAnn, d
    forall a. NoAnn a => a
    noAnn)

    instance NoAnn Bool where
      noAnn :: Bool
    noAnn = Bool
    False

    instance NoAnn () where
      noAnn :: ()
    noAnn = ()

    instance (NoAnn ann) => NoAnn (EpAnn ann) where
      noAnn :: EpAnn ann
    noAnn = EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    forall ann. EpaLocation -> ann -> EpAnnComments -> EpAnn ann
    EpAnn EpaLocation
    forall a. NoAnn a => EpaLocation' a
    noSpanAnchor ann
    forall a. NoAnn a => a
    noAnn EpAnnComments
    emptyComments

    instance NoAnn NoEpAnns where
      noAnn :: NoEpAnns
    noAnn = NoEpAnns
    NoEpAnns

    instance NoAnn AnnListItem where
      noAnn :: AnnListItem
    noAnn = [TrailingAnn] -> AnnListItem
    AnnListItem []

    instance NoAnn AnnContext where
      noAnn :: AnnContext
    noAnn = Maybe TokDarrow -> [EpToken "("] -> [EpToken ")"] -> AnnContext
    AnnContext Maybe TokDarrow
    forall a. Maybe a
    Nothing [] []

    instance NoAnn a => NoAnn (AnnList a) where
      noAnn :: AnnList a
    noAnn = Maybe EpaLocation
    -> AnnListBrackets
    -> [EpToken ";"]
    -> a
    -> [TrailingAnn]
    -> AnnList a
    forall a.
    Maybe EpaLocation
    -> AnnListBrackets
    -> [EpToken ";"]
    -> a
    -> [TrailingAnn]
    -> AnnList a
    AnnList Maybe EpaLocation
    forall a. Maybe a
    Nothing AnnListBrackets
    ListNone [EpToken ";"]
    forall a. NoAnn a => a
    noAnn a
    forall a. NoAnn a => a
    noAnn []

    instance NoAnn NameAnn where
      noAnn :: NameAnn
    noAnn = [TrailingAnn] -> NameAnn
    NameAnnTrailing []

    instance NoAnn AnnPragma where
      noAnn :: AnnPragma
    noAnn = EpaLocation
    -> EpToken "#-}"
    -> (EpToken "[", EpToken "]")
    -> EpaLocation
    -> EpaLocation
    -> EpToken "type"
    -> EpToken "module"
    -> AnnPragma
    AnnPragma EpaLocation
    forall a. NoAnn a => a
    noAnn EpToken "#-}"
    forall a. NoAnn a => a
    noAnn (EpToken "[", EpToken "]")
    forall a. NoAnn a => a
    noAnn EpaLocation
    forall a. NoAnn a => a
    noAnn EpaLocation
    forall a. NoAnn a => a
    noAnn EpToken "type"
    forall a. NoAnn a => a
    noAnn EpToken "module"
    forall a. NoAnn a => a
    noAnn

    instance NoAnn AnnParen where
      noAnn :: AnnParen
    noAnn = EpToken "(" -> EpToken ")" -> AnnParen
    AnnParens EpToken "("
    forall a. NoAnn a => a
    noAnn EpToken ")"
    forall a. NoAnn a => a
    noAnn

    instance NoAnn (EpToken s) where
      noAnn :: EpToken s
    noAnn = EpToken s
    forall (s :: Symbol). EpToken s
    NoEpTok

    instance NoAnn (EpUniToken s t) where
      noAnn :: EpUniToken s t
    noAnn = EpUniToken s t
    forall (s :: Symbol) (t :: Symbol). EpUniToken s t
    NoEpUniTok

    instance NoAnn SourceText where
      noAnn :: SourceText
    noAnn = SourceText
    NoSourceText

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

    instance (Outputable a) => Outputable (EpAnn a) where
      ppr :: EpAnn a -> SDoc
    ppr (EpAnn EpaLocation
    l a
    a EpAnnComments
    c)  = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "EpAnn" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation
    l SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr a
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpAnnComments -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpAnnComments
    c

    instance Outputable NoEpAnns where
      ppr :: NoEpAnns -> SDoc
    ppr NoEpAnns
    NoEpAnns = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NoEpAnns"

    instance Outputable (GenLocated NoCommentsLocation EpaComment) where
      ppr :: LEpaComment -> SDoc
    ppr (L EpaLocation' NoComments
    l EpaComment
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "L" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation' NoComments -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation' NoComments
    l SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaComment -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaComment
    c

    instance Outputable EpAnnComments where
      ppr :: EpAnnComments -> SDoc
    ppr (EpaComments [LEpaComment]
    cs) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "EpaComments" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [LEpaComment] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LEpaComment]
    cs
      ppr (EpaCommentsBalanced [LEpaComment]
    cs [LEpaComment]
    ts) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "EpaCommentsBalanced" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [LEpaComment] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LEpaComment]
    cs SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [LEpaComment] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LEpaComment]
    ts

    instance (NamedThing (Located a)) => NamedThing (LocatedAn an a) where
      getName :: LocatedAn an a -> Name
    getName (L EpAnn an
    l a
    a) = Located a -> Name
    forall a. NamedThing a => a -> Name
    getName (SrcSpan -> a -> Located a
    forall l e. l -> e -> GenLocated l e
    L (EpAnn an -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA EpAnn an
    l) a
    a)

    instance Outputable AnnContext where
      ppr :: AnnContext -> SDoc
    ppr (AnnContext Maybe TokDarrow
    a [EpToken "("]
    o [EpToken ")"]
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnContext" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe TokDarrow -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Maybe TokDarrow
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [EpToken "("] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [EpToken "("]
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [EpToken ")"] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [EpToken ")"]
    c

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

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

    instance Outputable tag => Outputable (AnnSortKey tag) where
      ppr :: AnnSortKey tag -> SDoc
    ppr AnnSortKey tag
    NoAnnSortKey    = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NoAnnSortKey"
      ppr (AnnSortKey [tag]
    ls) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnSortKey" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [tag] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [tag]
    ls

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

    instance (Outputable a, Outputable e)
         => Outputable (GenLocated (EpAnn a) e) where
      ppr :: GenLocated (EpAnn a) e -> SDoc
    ppr = GenLocated (EpAnn a) e -> SDoc
    forall l e. (Outputable l, Outputable e) => GenLocated l e -> SDoc
    pprLocated

    instance (Outputable a, OutputableBndr e)
         => OutputableBndr (GenLocated (EpAnn a) e) where
      pprInfixOcc :: GenLocated (EpAnn a) e -> SDoc
    pprInfixOcc = e -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprInfixOcc (e -> SDoc)
    -> (GenLocated (EpAnn a) e -> e) -> GenLocated (EpAnn a) e -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated (EpAnn a) e -> e
    forall l e. GenLocated l e -> e
    unLoc
      pprPrefixOcc :: GenLocated (EpAnn a) e -> SDoc
    pprPrefixOcc = e -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc (e -> SDoc)
    -> (GenLocated (EpAnn a) e -> e) -> GenLocated (EpAnn a) e -> SDoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GenLocated (EpAnn a) e -> e
    forall l e. GenLocated l e -> e
    unLoc

    instance (Outputable e)
         => Outputable (GenLocated EpaLocation e) where
      ppr :: GenLocated EpaLocation e -> SDoc
    ppr = GenLocated EpaLocation e -> SDoc
    forall l e. (Outputable l, Outputable e) => GenLocated l e -> SDoc
    pprLocated

    instance Outputable AnnParen where
      ppr :: AnnParen -> SDoc
    ppr (AnnParens       EpToken "("
    o EpToken ")"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnParens" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "(" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "("
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken ")" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken ")"
    c
      ppr (AnnParensHash   EpToken "(#"
    o EpToken "#)"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnParensHash" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "(#" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "(#"
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "#)" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "#)"
    c
      ppr (AnnParensSquare EpToken "["
    o EpToken "]"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnParensSquare" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "[" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "["
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "]" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "]"
    c

    instance Outputable AnnListItem where
      ppr :: AnnListItem -> SDoc
    ppr (AnnListItem [TrailingAnn]
    ts) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnListItem" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    ts

    instance Outputable NameAdornment where
      ppr :: NameAdornment -> SDoc
    ppr (NameParens     EpToken "("
    o EpToken ")"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameParens" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "(" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "("
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken ")" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken ")"
    c
      ppr (NameParensHash EpToken "(#"
    o EpToken "#)"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameParensHash" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "(#" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "(#"
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "#)" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "#)"
    c
      ppr (NameBackquotes EpToken "`"
    o EpToken "`"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameBackquotes" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "`" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "`"
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "`" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "`"
    c
      ppr (NameSquare     EpToken "["
    o EpToken "]"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameSquare" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "[" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "["
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "]" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "]"
    c
      ppr NameAdornment
    NameNoAdornment      = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameNoAdornment"

    instance Outputable NameAnn where
      ppr :: NameAnn -> SDoc
    ppr (NameAnn NameAdornment
    a EpaLocation
    n [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnn" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> NameAdornment -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr NameAdornment
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation
    n SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t
      ppr (NameAnnCommas NameAdornment
    a [EpToken ","]
    n [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnnCommas" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> NameAdornment -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr NameAdornment
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [EpToken ","] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [EpToken ","]
    n SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t
      ppr (NameAnnBars (EpToken "(#", EpToken "#)")
    a [EpToken "|"]
    n [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnnBars" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> (EpToken "(#", EpToken "#)") -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (EpToken "(#", EpToken "#)")
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [EpToken "|"] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [EpToken "|"]
    n SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t
      ppr (NameAnnOnly NameAdornment
    a [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnnOnly" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> NameAdornment -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr NameAdornment
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t
      ppr (NameAnnRArrow Maybe (EpToken "(")
    o TokRarrow
    n Maybe (EpToken ")")
    c [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnnRArrow" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe (EpToken "(") -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Maybe (EpToken "(")
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> TokRarrow -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TokRarrow
    n SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe (EpToken ")") -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Maybe (EpToken ")")
    c SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t
      ppr (NameAnnQuote EpToken "'"
    q SrcSpanAnnN
    n [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnnQuote" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "'" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "'"
    q SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SrcSpanAnnN -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr SrcSpanAnnN
    n SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t
      ppr (NameAnnTrailing [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NameAnnTrailing" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t

    instance (Outputable a) => Outputable (AnnList a) where
      ppr :: AnnList a -> SDoc
    ppr (AnnList Maybe EpaLocation
    anc AnnListBrackets
    p [EpToken ";"]
    s a
    a [TrailingAnn]
    t)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnList" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Maybe EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Maybe EpaLocation
    anc SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> AnnListBrackets -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr AnnListBrackets
    p SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [EpToken ";"] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [EpToken ";"]
    s SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr a
    a SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [TrailingAnn] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [TrailingAnn]
    t

    instance Outputable AnnListBrackets where
      ppr :: AnnListBrackets -> SDoc
    ppr (ListParens EpToken "("
    o EpToken ")"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ListParens" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "(" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "("
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken ")" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken ")"
    c
      ppr (ListBraces EpToken "{"
    o EpToken "}"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ListBraces" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "{" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "{"
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "}" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "}"
    c
      ppr (ListSquare EpToken "["
    o EpToken "]"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ListSquare" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "[" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "["
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "]" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "]"
    c
      ppr (ListBanana EpUniToken "(|" "\10631"
    o EpUniToken "|)" "\10632"
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ListBanana" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpUniToken "(|" "\10631" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpUniToken "(|" "\10631"
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpUniToken "|)" "\10632" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpUniToken "|)" "\10632"
    c
      ppr AnnListBrackets
    ListNone         = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "ListNone"

    instance Outputable AnnPragma where
      ppr :: AnnPragma -> SDoc
    ppr (AnnPragma EpaLocation
    o EpToken "#-}"
    c (EpToken "[", EpToken "]")
    s EpaLocation
    l EpaLocation
    ca EpToken "type"
    t EpToken "module"
    m)
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnnPragma" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation
    o SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "#-}" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "#-}"
    c SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> (EpToken "[", EpToken "]") -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (EpToken "[", EpToken "]")
    s SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation
    l
                           SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation
    ca SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpaLocation -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpaLocation
    ca SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "type" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "type"
    t SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> EpToken "module" -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr EpToken "module"
    m