{-# 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