-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | ExactPrint for GHC
--   
--   Using the API Annotations available from GHC 9.2.1, this library
--   provides a means to round trip any code that can be compiled by GHC,
--   currently excluding lhs files.
--   
--   Note: requires GHC 9.10.*. For earlier GHC versions see lower version
--   numbers.
@package ghc-exactprint
@version 1.10.0.0

module Language.Haskell.GHC.ExactPrint.Types
type Pos = (Int, Int)

-- | A Haskell comment. The <tt>AnnKeywordId</tt> is present if it has been
--   converted from an <tt>AnnKeywordId</tt> because the annotation must be
--   interleaved into the stream and does not have a well-defined position
data Comment
Comment :: !String -> !NoCommentsLocation -> !RealSrcSpan -> !Maybe AnnKeywordId -> Comment

-- | The contents of the comment including separators
[commentContents] :: Comment -> !String
[commentLoc] :: Comment -> !NoCommentsLocation
[commentPriorTok] :: Comment -> !RealSrcSpan

-- | We sometimes turn syntax into comments in order to process them
--   properly.
[commentOrigin] :: Comment -> !Maybe AnnKeywordId

-- | Marks the start column of a layout block.
newtype LayoutStartCol
LayoutStartCol :: Int -> LayoutStartCol
[getLayoutStartCol] :: LayoutStartCol -> Int
showGhc :: Outputable a => a -> String
instance GHC.Internal.Data.Data.Data Language.Haskell.GHC.ExactPrint.Types.Comment
instance GHC.Classes.Eq Language.Haskell.GHC.ExactPrint.Types.Comment
instance GHC.Classes.Eq Language.Haskell.GHC.ExactPrint.Types.LayoutStartCol
instance GHC.Internal.Num.Num Language.Haskell.GHC.ExactPrint.Types.LayoutStartCol
instance GHC.Classes.Ord Language.Haskell.GHC.ExactPrint.Types.Comment
instance GHC.Utils.Outputable.Outputable Language.Haskell.GHC.ExactPrint.Types.Comment
instance GHC.Internal.Show.Show Language.Haskell.GHC.ExactPrint.Types.Comment
instance GHC.Internal.Show.Show Language.Haskell.GHC.ExactPrint.Types.LayoutStartCol

module Language.Haskell.GHC.ExactPrint.Lookup

-- | Maps <a>AnnKeywordId</a> to the corresponding String representation.
--   There is no specific mapping for the following constructors.
--   <a>AnnOpen</a>, <a>AnnClose</a>, <a>AnnVal</a>, <a>AnnPackageName</a>,
--   <a>AnnHeader</a>, <a>AnnFunId</a>, <a>AnnInfix</a>
keywordToString :: AnnKeywordId -> String

-- | Exact print annotations exist so that tools can perform source to
--   source conversions of Haskell code. They are used to keep track of the
--   various syntactic keywords that are not otherwise captured in the AST.
--   
--   The wiki page describing this feature is
--   <a>https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations</a>
--   <a>https://gitlab.haskell.org/ghc/ghc/-/wikis/implementing-trees-that-grow/in-tree-api-annotations</a>
--   
--   Note: in general the names of these are taken from the corresponding
--   token, unless otherwise noted See Note [exact print annotations] above
--   for details of the usage
data AnnKeywordId
AnnAnyclass :: AnnKeywordId
AnnAs :: AnnKeywordId

-- | <tt>!</tt>
AnnBang :: AnnKeywordId

-- | '`'
AnnBackquote :: AnnKeywordId
AnnBy :: AnnKeywordId

-- | case or lambda case
AnnCase :: AnnKeywordId

-- | lambda cases
AnnCases :: AnnKeywordId
AnnClass :: AnnKeywordId

-- | '#)' or '#-}' etc
AnnClose :: AnnKeywordId

-- | '|)'
AnnCloseB :: AnnKeywordId

-- | '|)', unicode variant
AnnCloseBU :: AnnKeywordId

-- | '}'
AnnCloseC :: AnnKeywordId

-- | '|]'
AnnCloseQ :: AnnKeywordId

-- | '|]', unicode variant
AnnCloseQU :: AnnKeywordId

-- | ')'
AnnCloseP :: AnnKeywordId

-- | '#)'
AnnClosePH :: AnnKeywordId

-- | ']'
AnnCloseS :: AnnKeywordId
AnnColon :: AnnKeywordId

-- | as a list separator
AnnComma :: AnnKeywordId

-- | in a RdrName for a tuple
AnnCommaTuple :: AnnKeywordId

-- | '=&gt;'
AnnDarrow :: AnnKeywordId

-- | '=&gt;', unicode variant
AnnDarrowU :: AnnKeywordId
AnnData :: AnnKeywordId

-- | '::'
AnnDcolon :: AnnKeywordId

-- | '::', unicode variant
AnnDcolonU :: AnnKeywordId
AnnDefault :: AnnKeywordId
AnnDeriving :: AnnKeywordId
AnnDo :: AnnKeywordId

-- | <a>.</a>
AnnDot :: AnnKeywordId

-- | '..'
AnnDotdot :: AnnKeywordId
AnnElse :: AnnKeywordId
AnnEqual :: AnnKeywordId
AnnExport :: AnnKeywordId
AnnFamily :: AnnKeywordId
AnnForall :: AnnKeywordId

-- | Unicode variant
AnnForallU :: AnnKeywordId
AnnForeign :: AnnKeywordId

-- | for function name in matches where there are multiple equations for
--   the function.
AnnFunId :: AnnKeywordId
AnnGroup :: AnnKeywordId

-- | for CType
AnnHeader :: AnnKeywordId
AnnHiding :: AnnKeywordId
AnnIf :: AnnKeywordId
AnnImport :: AnnKeywordId
AnnIn :: AnnKeywordId

-- | 'infix' or 'infixl' or 'infixr'
AnnInfix :: AnnKeywordId
AnnInstance :: AnnKeywordId
AnnLam :: AnnKeywordId

-- | '&lt;-'
AnnLarrow :: AnnKeywordId

-- | '&lt;-', unicode variant
AnnLarrowU :: AnnKeywordId
AnnLet :: AnnKeywordId

-- | The <tt>⊸</tt> unicode arrow
AnnLollyU :: AnnKeywordId
AnnMdo :: AnnKeywordId

-- | <a>-</a>
AnnMinus :: AnnKeywordId
AnnModule :: AnnKeywordId
AnnNewtype :: AnnKeywordId

-- | where a name loses its location in the AST, this carries it
AnnName :: AnnKeywordId
AnnOf :: AnnKeywordId

-- | '{-# DEPRECATED' etc. Opening of pragmas where the capitalisation of
--   the string can be changed by the user. The actual text used is stored
--   in a <tt>SourceText</tt> on the relevant pragma item.
AnnOpen :: AnnKeywordId

-- | '(|'
AnnOpenB :: AnnKeywordId

-- | '(|', unicode variant
AnnOpenBU :: AnnKeywordId

-- | '{'
AnnOpenC :: AnnKeywordId

-- | '[e|' or '[e||'
AnnOpenE :: AnnKeywordId

-- | '[|'
AnnOpenEQ :: AnnKeywordId

-- | '[|', unicode variant
AnnOpenEQU :: AnnKeywordId

-- | '('
AnnOpenP :: AnnKeywordId

-- | '['
AnnOpenS :: AnnKeywordId

-- | '(#'
AnnOpenPH :: AnnKeywordId

-- | prefix <a>$</a> -- TemplateHaskell
AnnDollar :: AnnKeywordId

-- | prefix <a>$$</a> -- TemplateHaskell
AnnDollarDollar :: AnnKeywordId
AnnPackageName :: AnnKeywordId
AnnPattern :: AnnKeywordId

-- | <tt>%</tt> -- for HsExplicitMult
AnnPercent :: AnnKeywordId

-- | '%1' -- for HsLinearArrow
AnnPercentOne :: AnnKeywordId
AnnProc :: AnnKeywordId
AnnQualified :: AnnKeywordId

-- | <tt>-&gt;</tt>
AnnRarrow :: AnnKeywordId

-- | <tt>-&gt;</tt>, unicode variant
AnnRarrowU :: AnnKeywordId
AnnRec :: AnnKeywordId
AnnRole :: AnnKeywordId
AnnSafe :: AnnKeywordId

-- | ';'
AnnSemi :: AnnKeywordId

-- | '''
AnnSimpleQuote :: AnnKeywordId
AnnSignature :: AnnKeywordId

-- | <tt>static</tt>
AnnStatic :: AnnKeywordId
AnnStock :: AnnKeywordId
AnnThen :: AnnKeywordId

-- | double '''
AnnThTyQuote :: AnnKeywordId

-- | <a>~</a>
AnnTilde :: AnnKeywordId
AnnType :: AnnKeywordId

-- | <tt>()</tt> for types
AnnUnit :: AnnKeywordId
AnnUsing :: AnnKeywordId

-- | e.g. INTEGER
AnnVal :: AnnKeywordId

-- | String value, will need quotes when output
AnnValStr :: AnnKeywordId

-- | '|'
AnnVbar :: AnnKeywordId

-- | <tt>via</tt>
AnnVia :: AnnKeywordId
AnnWhere :: AnnKeywordId

-- | <tt>-&lt;</tt>
Annlarrowtail :: AnnKeywordId

-- | <tt>-&lt;</tt>, unicode variant
AnnlarrowtailU :: AnnKeywordId

-- | <tt>-&gt;</tt>
Annrarrowtail :: AnnKeywordId

-- | <tt>-&gt;</tt>, unicode variant
AnnrarrowtailU :: AnnKeywordId

-- | <tt>-&lt;&lt;</tt>
AnnLarrowtail :: AnnKeywordId

-- | <tt>-&lt;&lt;</tt>, unicode variant
AnnLarrowtailU :: AnnKeywordId

-- | <tt>&gt;&gt;-</tt>
AnnRarrowtail :: AnnKeywordId

-- | <tt>&gt;&gt;-</tt>, unicode variant
AnnRarrowtailU :: AnnKeywordId

-- | A Haskell comment. The <tt>AnnKeywordId</tt> is present if it has been
--   converted from an <tt>AnnKeywordId</tt> because the annotation must be
--   interleaved into the stream and does not have a well-defined position
data Comment
Comment :: !String -> !NoCommentsLocation -> !RealSrcSpan -> !Maybe AnnKeywordId -> Comment

-- | The contents of the comment including separators
[commentContents] :: Comment -> !String
[commentLoc] :: Comment -> !NoCommentsLocation
[commentPriorTok] :: Comment -> !RealSrcSpan

-- | We sometimes turn syntax into comments in order to process them
--   properly.
[commentOrigin] :: Comment -> !Maybe AnnKeywordId

module Language.Haskell.GHC.ExactPrint.Utils

-- | Global switch to enable debug tracing in ghc-exactprint Delta / Print
debugEnabledFlag :: Bool

-- | Provide a version of trace that comes at the end of the line, so it
--   can easily be commented out when debugging different things.
debug :: c -> String -> c
debugM :: Monad m => String -> m ()
warn :: c -> String -> c
captureOrderBinds :: [LHsDecl GhcPs] -> AnnSortKey BindTag
notDocDecl :: LHsDecl GhcPs -> Bool
notIEDoc :: LIE GhcPs -> Bool

-- | A good delta has no negative values.
isGoodDelta :: DeltaPos -> Bool

-- | Create a delta from the current position to the start of the given
--   <tt>RealSrcSpan</tt>.
ss2delta :: Pos -> RealSrcSpan -> DeltaPos

-- | create a delta from the end of a current span. The +1 is because the
--   stored position ends up one past the span, this is prior to that
--   adjustment
ss2deltaEnd :: RealSrcSpan -> RealSrcSpan -> DeltaPos

-- | create a delta from the start of a current span. The +1 is because the
--   stored position ends up one past the span, this is prior to that
--   adjustment
ss2deltaStart :: RealSrcSpan -> RealSrcSpan -> DeltaPos

-- | Convert the start of the second <tt>Pos</tt> to be an offset from the
--   first. The assumption is the reference starts before the second
--   <tt>Pos</tt>
pos2delta :: Pos -> Pos -> DeltaPos

-- | Apply the delta to the current position, taking into account the
--   current column offset if advancing to a new line
undelta :: Pos -> DeltaPos -> LayoutStartCol -> Pos
undeltaSpan :: RealSrcSpan -> AnnKeywordId -> DeltaPos -> AddEpAnn
adjustDeltaForOffset :: LayoutStartCol -> DeltaPos -> DeltaPos
ss2pos :: RealSrcSpan -> Pos
ss2posEnd :: RealSrcSpan -> Pos
ss2range :: SrcSpan -> (Pos, Pos)
rs2range :: RealSrcSpan -> (Pos, Pos)
rs :: SrcSpan -> RealSrcSpan
range2rs :: (Pos, Pos) -> RealSrcSpan
badRealSrcSpan :: RealSrcSpan
spanLength :: RealSrcSpan -> Int

-- | Useful for debug dumps
eloc2str :: EpaLocation -> String

-- | Checks whether a SrcSpan has zero length.
isPointSrcSpan :: RealSrcSpan -> Bool

-- | A GHC comment includes the span of the preceding token. Take an
--   original comment, and convert the 'Anchor to have a have a
--   <tt>MovedAnchor</tt> operation based on the original location, only if
--   it does not already have one.
commentOrigDelta :: LEpaComment -> LEpaComment
origDelta :: RealSrcSpan -> RealSrcSpan -> DeltaPos
needsWhere :: forall (p :: Pass). DataDefnCons (LConDecl (GhcPass p)) -> Bool

-- | Insert the comments at the appropriate places in the AST
insertCppComments :: ParsedSource -> [LEpaComment] -> ParsedSource
workInComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
insertTopLevelCppComments :: HsModule GhcPs -> [LEpaComment] -> (HsModule GhcPs, [LEpaComment])
data SplitWhere
Before :: SplitWhere
After :: SplitWhere
splitOnWhere :: SplitWhere -> [AddEpAnn] -> [LEpaComment] -> ([LEpaComment], [LEpaComment])
balanceFirstLocatedAComments :: [LocatedA a] -> ([LocatedA a], [LEpaComment])
priorCommentsDeltas' :: RealSrcSpan -> [LEpaComment] -> [(Int, LEpaComment)]
allocatePriorComments :: Pos -> [LEpaComment] -> ([LEpaComment], [LEpaComment])
insertRemainingCppComments :: ParsedSource -> [LEpaComment] -> ParsedSource
ghcCommentText :: LEpaComment -> String
tokComment :: LEpaComment -> [Comment]
hsDocStringComments :: Anchor -> RealSrcSpan -> HsDocString -> [Comment]
dedentDocChunk :: LHsDocStringChunk -> LHsDocStringChunk
dedentDocChunkBy :: Int -> LHsDocStringChunk -> LHsDocStringChunk
epaCommentsBalanced :: [LEpaComment] -> [LEpaComment] -> EpAnnComments
mkEpaComments :: [Comment] -> [Comment] -> EpAnnComments
comment2LEpaComment :: Comment -> LEpaComment
mkLEpaComment :: String -> NoCommentsLocation -> RealSrcSpan -> LEpaComment
mkComment :: String -> NoCommentsLocation -> RealSrcSpan -> Comment
normaliseCommentText :: String -> String

-- | Must compare without span filenames, for CPP injected comments with
--   fake filename
cmpComments :: Comment -> Comment -> Ordering

-- | Sort, comparing without span filenames, for CPP injected comments with
--   fake filename
sortComments :: [Comment] -> [Comment]

-- | Sort, comparing without span filenames, for CPP injected comments with
--   fake filename
sortEpaComments :: [LEpaComment] -> [LEpaComment]

-- | Makes a comment which originates from a specific keyword.
mkKWComment :: AnnKeywordId -> NoCommentsLocation -> Comment
sortAnchorLocated :: [GenLocated Anchor a] -> [GenLocated Anchor a]

-- | Calculates the distance from the start of a string to the end of a
--   string.
dpFromString :: String -> DeltaPos
isSymbolRdrName :: RdrName -> Bool
rdrName2String :: RdrName -> String
name2String :: Name -> String
trailingAnnLoc :: TrailingAnn -> EpaLocation
setTrailingAnnLoc :: TrailingAnn -> EpaLocation -> TrailingAnn
addEpAnnLoc :: AddEpAnn -> EpaLocation
type DeclsByTag a = Map DeclTag [(RealSrcSpan, a)]
orderedDecls :: AnnSortKey DeclTag -> DeclsByTag a -> [(RealSrcSpan, a)]
hsDeclsClassDecl :: TyClDecl GhcPs -> [LHsDecl GhcPs]
replaceDeclsClassDecl :: TyClDecl GhcPs -> [LHsDecl GhcPs] -> TyClDecl GhcPs
partitionWithSortKey :: [LHsDecl GhcPs] -> ([DeclTag], LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs], [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs])
orderedDeclsBinds :: AnnSortKey BindTag -> [LHsDecl GhcPs] -> [LHsDecl GhcPs] -> [LHsDecl GhcPs]
hsDeclsLocalBinds :: HsLocalBinds GhcPs -> [LHsDecl GhcPs]
hsDeclsValBinds :: HsValBindsLR GhcPs GhcPs -> [LHsDecl GhcPs]

-- | Pure function to convert a <a>LHsDecl</a> to a <a>LHsBind</a>. This
--   does nothing to any annotations that may be attached to either of the
--   elements. It is used as a utility function in <tt>replaceDecls</tt>
decl2Bind :: LHsDecl GhcPs -> [LHsBind GhcPs]

-- | Pure function to convert a <a>LSig</a> to a <a>LHsBind</a>. This does
--   nothing to any annotations that may be attached to either of the
--   elements. It is used as a utility function in <tt>replaceDecls</tt>
decl2Sig :: LHsDecl GhcPs -> [LSig GhcPs]

-- | Convert a <a>LSig</a> into a <a>LHsDecl</a>
wrapSig :: LSig GhcPs -> LHsDecl GhcPs

-- | Convert a <a>LHsBind</a> into a <a>LHsDecl</a>
wrapDecl :: LHsBind GhcPs -> LHsDecl GhcPs
showAst :: Data a => a -> String


-- | This module is currently under heavy development, and no promises are
--   made about API stability. Use with care.
--   
--   We welcome any feedback / contributions on this, as it is the main
--   point of the library.
module Language.Haskell.GHC.ExactPrint.Transform

-- | Monad type for updating the AST and managing the annotations at the
--   same time. The W state is used to generate logging information if
--   required.
type Transform = TransformT Identity

-- | Monad transformer version of <a>Transform</a> monad
newtype TransformT (m :: Type -> Type) a
TransformT :: RWST () [String] Int m a -> TransformT (m :: Type -> Type) a
[unTransformT] :: TransformT (m :: Type -> Type) a -> RWST () [String] Int m a

-- | Change inner monad of <a>TransformT</a>.
hoistTransform :: (forall x. () => m x -> n x) -> TransformT m a -> TransformT n a

-- | Run a transformation in the <a>Transform</a> monad, returning the
--   updated annotations and any logging generated via <a>logTr</a>
runTransform :: Transform a -> (a, Int, [String])
runTransformT :: TransformT m a -> m (a, Int, [String])

-- | Run a transformation in the <a>Transform</a> monad, returning the
--   updated annotations and any logging generated via <a>logTr</a>,
--   allocating any new SrcSpans from the provided initial value.
runTransformFrom :: Int -> Transform a -> (a, Int, [String])

-- | Run a monad transformer stack for the <a>TransformT</a> monad
--   transformer
runTransformFromT :: Int -> TransformT m a -> m (a, Int, [String])

-- | Log a string to the output of the Monad
logTr :: forall (m :: Type -> Type). Monad m => String -> TransformT m ()

-- | Log a representation of the given AST with annotations to the output
--   of the Monad
logDataWithAnnsTr :: forall (m :: Type -> Type) a. (Monad m, Data a) => String -> a -> TransformT m ()

-- | If we need to add new elements to the AST, they need their own
--   <a>SrcSpan</a> for this. This should no longer be needed, we use an
--   <tt>EpaDelta</tt> location instead.
uniqueSrcSpanT :: forall (m :: Type -> Type). Monad m => TransformT m SrcSpan

-- | Used to integrate a <tt>Transform</tt> into other Monad stacks
class Monad m => HasTransform (m :: Type -> Type)
liftT :: HasTransform m => Transform a -> m a

-- | Provide a means to get and process the immediate child declarations of
--   a given AST element.
class Data t => HasDecls t

-- | Return the <a>HsDecl</a>s that are directly enclosed in the given
--   syntax phrase. They are always returned in the wrapped <a>HsDecl</a>
--   form, even if orginating in local decls. This is safe, as annotations
--   never attach to the wrapper, only to the wrapped item.
hsDecls :: HasDecls t => t -> [LHsDecl GhcPs]

-- | Replace the directly enclosed decl list by the given decl list. As
--   parto of replacing it will update list order annotations, and
--   rebalance comments and other layout changes as needed.
--   
--   For example, a call on replaceDecls for a wrapped <a>FunBind</a>
--   having no where clause will convert
--   
--   <pre>
--   -- |This is a function
--   foo = x -- comment1
--   </pre>
--   
--   in to
--   
--   <pre>
--   -- |This is a function
--   foo = x -- comment1
--     where
--       nn = 2
--   </pre>
replaceDecls :: HasDecls t => t -> [LHsDecl GhcPs] -> t

-- | Extract the immediate declarations for a <a>PatBind</a>. This cannot
--   be a member of <a>HasDecls</a> because a <a>FunBind</a> is not
--   idempotent for <a>hsDecls</a> / <a>replaceDecls</a>.
--   <a>hsDeclsPatBind</a> / <a>replaceDeclsPatBind</a> is idempotent.
hsDeclsPatBind :: LHsBind GhcPs -> [LHsDecl GhcPs]

-- | Extract the immediate declarations for a <a>PatBind</a> wrapped in a
--   <a>ValD</a>. This cannot be a member of <a>HasDecls</a> because a
--   <a>FunBind</a> is not idempotent for <a>hsDecls</a> /
--   <a>replaceDecls</a>. <a>hsDeclsPatBindD</a> /
--   <a>replaceDeclsPatBindD</a> is idempotent.
hsDeclsPatBindD :: LHsDecl GhcPs -> [LHsDecl GhcPs]

-- | Replace the immediate declarations for a <a>PatBind</a>. This cannot
--   be a member of <a>HasDecls</a> because a <a>FunBind</a> is not
--   idempotent for <a>hsDecls</a> / <a>replaceDecls</a>.
--   <a>hsDeclsPatBind</a> / <a>replaceDeclsPatBind</a> is idempotent.
replaceDeclsPatBind :: LHsBind GhcPs -> [LHsDecl GhcPs] -> LHsBind GhcPs

-- | Replace the immediate declarations for a <a>PatBind</a> wrapped in a
--   <a>ValD</a>. This cannot be a member of <a>HasDecls</a> because a
--   <a>FunBind</a> is not idempotent for <a>hsDecls</a> /
--   <a>replaceDecls</a>. <a>hsDeclsPatBindD</a> /
--   <a>replaceDeclsPatBindD</a> is idempotent.
replaceDeclsPatBindD :: LHsDecl GhcPs -> [LHsDecl GhcPs] -> LHsDecl GhcPs

-- | Apply a transformation to the decls contained in <tt>t</tt>
modifyDeclsT :: (HasDecls t, HasTransform m) => ([LHsDecl GhcPs] -> m [LHsDecl GhcPs]) -> t -> m t

-- | Modify a <a>LHsBind</a> wrapped in a <a>ValD</a>. For a <a>PatBind</a>
--   the declarations are extracted and returned after modification. For a
--   <a>FunBind</a> the supplied <a>SrcSpan</a> is used to identify the
--   specific <a>Match</a> to be transformed, for when there are multiple
--   of them.
modifyValD :: SrcSpan -> Decl -> (PMatch -> [Decl] -> ([Decl], Maybe t)) -> (Decl, Maybe t)
hsDeclsValBinds :: HsValBindsLR GhcPs GhcPs -> [LHsDecl GhcPs]

-- | Utility function for returning decls to <a>HsLocalBinds</a>. Use with
--   care, as this does not manage the declaration order, the ordering
--   should be done by the calling function from the <a>HsLocalBinds</a>
--   context in the AST.
replaceDeclsValbinds :: WithWhere -> HsLocalBinds GhcPs -> [LHsDecl GhcPs] -> HsLocalBinds GhcPs
data WithWhere
WithWhere :: WithWhere
WithoutWhere :: WithWhere

-- | Create a <tt>SrcSpanAnn</tt> with a <tt>MovedAnchor</tt> operation
--   using the given <tt>DeltaPos</tt>.
noAnnSrcSpanDP :: NoAnn ann => DeltaPos -> EpAnn ann
noAnnSrcSpanDP0 :: NoAnn ann => EpAnn ann
noAnnSrcSpanDP1 :: NoAnn ann => EpAnn ann
noAnnSrcSpanDPn :: NoAnn ann => Int -> EpAnn ann
d0 :: EpaLocation
d1 :: EpaLocation
dn :: Int -> EpaLocation
addComma :: SrcSpanAnnA -> SrcSpanAnnA

-- | Insert a declaration into an AST element having sub-declarations
--   (<tt>HasDecls</tt>) according to the given location function.
insertAt :: HasDecls ast => (LHsDecl GhcPs -> [LHsDecl GhcPs] -> [LHsDecl GhcPs]) -> ast -> LHsDecl GhcPs -> ast

-- | Insert a declaration at the beginning or end of the subdecls of the
--   given AST item
insertAtStart :: HasDecls ast => ast -> LHsDecl GhcPs -> ast

-- | Insert a declaration at the beginning or end of the subdecls of the
--   given AST item
insertAtEnd :: HasDecls ast => ast -> LHsDecl GhcPs -> ast

-- | Insert a declaration at a specific location in the subdecls of the
--   given AST item
insertAfter :: HasDecls (LocatedA ast) => LocatedA old -> LocatedA ast -> LHsDecl GhcPs -> LocatedA ast

-- | Insert a declaration at a specific location in the subdecls of the
--   given AST item
insertBefore :: HasDecls (LocatedA ast) => LocatedA old -> LocatedA ast -> LHsDecl GhcPs -> LocatedA ast

-- | The GHC parser puts all comments appearing between the end of one AST
--   item and the beginning of the next as <tt>annPriorComments</tt> for
--   the second one. This function takes two adjacent AST items and moves
--   any <tt>annPriorComments</tt> from the second one to the
--   <tt>annFollowingComments</tt> of the first if they belong to it
--   instead. This is typically required before deleting or duplicating
--   either of the AST elements.
balanceComments :: LHsDecl GhcPs -> LHsDecl GhcPs -> (LHsDecl GhcPs, LHsDecl GhcPs)

-- | If we compile in haddock mode we get DocDecls, which we strip out
--   while exact printing. Make sure we do not balance any comments on to
--   them be stripping them out here already.
balanceCommentsList :: [LHsDecl GhcPs] -> [LHsDecl GhcPs]
balanceCommentsListA :: [LocatedA a] -> [LocatedA a]
anchorEof :: ParsedSource -> ParsedSource
captureOrderBinds :: [LHsDecl GhcPs] -> AnnSortKey BindTag
captureLineSpacing :: [LocatedA e] -> [LocatedA e]
captureMatchLineSpacing :: LHsDecl GhcPs -> LHsDecl GhcPs
captureTypeSigSpacing :: LHsDecl GhcPs -> LHsDecl GhcPs

-- | Test whether a given <a>SrcSpan</a> was generated by
--   <a>uniqueSrcSpanT</a>
isUniqueSrcSpan :: SrcSpan -> Bool

-- | Set the true entry <a>DeltaPos</a> from the annotation for a given AST
--   element. This is the <a>DeltaPos</a> ignoring any comments.
setEntryDP :: LocatedAn t a -> DeltaPos -> LocatedAn t a
setEntryDPDecl :: LHsDecl GhcPs -> DeltaPos -> LHsDecl GhcPs
getEntryDP :: LocatedAn t a -> DeltaPos

-- | Take the annEntryDelta associated with the first item and associate it
--   with the second. Also transfer any comments occurring before it.
transferEntryDP :: (Typeable t1, Typeable t2) => LocatedAn t1 a -> LocatedAn t2 b -> LocatedAn t2 b

-- | Take the annEntryDelta associated with the first item and associate it
--   with the second. Also transfer any comments occurring before it. TODO:
--   call transferEntryDP, and use pushDeclDP
transferEntryDP' :: LHsDecl GhcPs -> LHsDecl GhcPs -> LHsDecl GhcPs

-- | Convert a <a>LSig</a> into a <a>LHsDecl</a>
wrapSig :: LSig GhcPs -> LHsDecl GhcPs

-- | Convert a <a>LHsBind</a> into a <a>LHsDecl</a>
wrapDecl :: LHsBind GhcPs -> LHsDecl GhcPs

-- | Pure function to convert a <a>LSig</a> to a <a>LHsBind</a>. This does
--   nothing to any annotations that may be attached to either of the
--   elements. It is used as a utility function in <tt>replaceDecls</tt>
decl2Sig :: LHsDecl GhcPs -> [LSig GhcPs]

-- | Pure function to convert a <a>LHsDecl</a> to a <a>LHsBind</a>. This
--   does nothing to any annotations that may be attached to either of the
--   elements. It is used as a utility function in <tt>replaceDecls</tt>
decl2Bind :: LHsDecl GhcPs -> [LHsBind GhcPs]
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance GHC.Classes.Eq Language.Haskell.GHC.ExactPrint.Transform.WithWhere
instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance Language.Haskell.GHC.ExactPrint.Transform.HasDecls (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.Match GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs))))
instance Language.Haskell.GHC.ExactPrint.Transform.HasDecls (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs))
instance Language.Haskell.GHC.ExactPrint.Transform.HasDecls (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.Stmt GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs))))
instance Language.Haskell.GHC.ExactPrint.Transform.HasDecls GHC.ParsedSource
instance Language.Haskell.GHC.ExactPrint.Transform.HasDecls (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Decls.HsDecl GHC.Hs.Extension.GhcPs))
instance GHC.Internal.Base.Monad m => Language.Haskell.GHC.ExactPrint.Transform.HasTransform (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance GHC.Internal.Base.Monad m => Control.Monad.Reader.Class.MonadReader () (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance GHC.Internal.Base.Monad m => Control.Monad.State.Class.MonadState GHC.Types.Int (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance Control.Monad.Trans.Class.MonadTrans Language.Haskell.GHC.ExactPrint.Transform.TransformT
instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance GHC.Internal.Base.Monad m => Control.Monad.Writer.Class.MonadWriter [GHC.Internal.Base.String] (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
instance GHC.Internal.Show.Show Language.Haskell.GHC.ExactPrint.Transform.WithWhere


-- | This module provides support for CPP, interpreter directives and line
--   pragmas.
module Language.Haskell.GHC.ExactPrint.Preprocess

-- | Remove GHC style line pragmas (<tt>{-# LINE .. #-}</tt>) and convert
--   them into comments.
stripLinePragmas :: String -> (String, [LEpaComment])

-- | Replacement for original <tt>getRichTokenStream</tt> which will return
--   the tokens for a file processed by CPP. See bug
--   <a>http://ghc.haskell.org/trac/ghc/ticket/8265</a>
getCppTokensAsComments :: GhcMonad m => CppOptions -> FilePath -> m [LEpaComment]
getPreprocessedSrcDirect :: GhcMonad m => CppOptions -> FilePath -> m (String, DynFlags)
readFileGhc :: FilePath -> IO String
data CppOptions
CppOptions :: [String] -> [FilePath] -> [FilePath] -> CppOptions

-- | CPP #define macros
[cppDefine] :: CppOptions -> [String]

-- | CPP Includes directory
[cppInclude] :: CppOptions -> [FilePath]

-- | CPP pre-include file
[cppFile] :: CppOptions -> [FilePath]
defaultCppOptions :: CppOptions


-- | This module rexposes wrapped parsers from the GHC API. Along with
--   returning the parse result, the corresponding annotations are also
--   returned such that it is then easy to modify the annotations and print
--   the result.
module Language.Haskell.GHC.ExactPrint.Parsers
type Parser a = DynFlags -> FilePath -> String -> ParseResult a
type ParseResult a = Either ErrorMessages a

-- | Provides a safe way to consume a properly initialised set of
--   <tt>DynFlags</tt>.
--   
--   <pre>
--   myParser fname expr = withDynFlags (\d -&gt; parseExpr d fname expr)
--   </pre>
withDynFlags :: LibDir -> (DynFlags -> a) -> IO a
data CppOptions
CppOptions :: [String] -> [FilePath] -> [FilePath] -> CppOptions

-- | CPP #define macros
[cppDefine] :: CppOptions -> [String]

-- | CPP Includes directory
[cppInclude] :: CppOptions -> [FilePath]

-- | CPP pre-include file
[cppFile] :: CppOptions -> [FilePath]
defaultCppOptions :: CppOptions
type LibDir = FilePath

-- | This entry point will also work out which language extensions are
--   required and perform CPP processing if necessary.
--   
--   <pre>
--   parseModule = parseModuleWithCpp defaultCppOptions
--   </pre>
--   
--   Note: <a>ParsedSource</a> is a synonym for <a>Located</a>
--   (<a>HsModule</a> <tt>GhcPs</tt>)
parseModule :: LibDir -> FilePath -> IO (ParseResult ParsedSource)

-- | This entry point will work out which language extensions are required
--   but will _not_ perform CPP processing. In contrast to
--   <tt>parseModoule</tt> the input source is read from the provided
--   string; the <a>FilePath</a> parameter solely exists to provide a name
--   in source location annotations.
parseModuleFromString :: LibDir -> FilePath -> String -> IO (ParseResult ParsedSource)
parseModuleWithOptions :: LibDir -> FilePath -> IO (ParseResult ParsedSource)

-- | Parse a module with specific instructions for the C pre-processor.
parseModuleWithCpp :: LibDir -> CppOptions -> FilePath -> IO (ParseResult ParsedSource)
parseExpr :: Parser (LHsExpr GhcPs)
parseImport :: Parser (LImportDecl GhcPs)
parseType :: Parser (LHsType GhcPs)
parseDecl :: Parser (LHsDecl GhcPs)
parsePattern :: Parser (LPat GhcPs)
parseStmt :: Parser (ExprLStmt GhcPs)

-- | Wrapper function which returns Annotations along with the parsed
--   element.
parseWith :: DynFlags -> FilePath -> P w -> String -> ParseResult w

-- | Internal function. Default runner of GHC.Ghc action in IO.
ghcWrapper :: LibDir -> Ghc a -> IO a

-- | Internal function. Initializes DynFlags value for parsing.
--   
--   Passes "-hide-all-packages" to the GHC API to prevent parsing of
--   package environment files. However this only works if there is no
--   invocation of <tt>setSessionDynFlags</tt> before calling
--   <a>initDynFlags</a>. See ghc tickets #15513, #15541.
initDynFlags :: GhcMonad m => FilePath -> m DynFlags

-- | Requires GhcMonad constraint because there is no pure variant of
--   <tt>parseDynamicFilePragma</tt>. Yet, in constrast to
--   <a>initDynFlags</a>, it does not (try to) read the file at filepath,
--   but solely depends on the module source in the input string.
--   
--   Passes "-hide-all-packages" to the GHC API to prevent parsing of
--   package environment files. However this only works if there is no
--   invocation of <tt>setSessionDynFlags</tt> before calling
--   <a>initDynFlagsPure</a>. See ghc tickets #15513, #15541.
initDynFlagsPure :: GhcMonad m => FilePath -> String -> m DynFlags

-- | Internal part of <a>parseModuleFromString</a>.
parseModuleFromStringInternal :: Parser ParsedSource

-- | Low level function which is used in the internal tests. It is advised
--   to use <a>parseModule</a> or <a>parseModuleWithCpp</a> instead of this
--   function.
parseModuleEpAnnsWithCpp :: LibDir -> CppOptions -> FilePath -> IO (Either ErrorMessages ([LEpaComment], DynFlags, ParsedSource))

-- | Internal function. Exposed if you want to muck with DynFlags before
--   parsing.
parseModuleEpAnnsWithCppInternal :: GhcMonad m => CppOptions -> DynFlags -> FilePath -> m (Either ErrorMessages ([LEpaComment], DynFlags, ParsedSource))

-- | Internal function. Exposed if you want to muck with DynFlags before
--   parsing. Or after parsing.
postParseTransform :: Either a ([LEpaComment], DynFlags, ParsedSource) -> Either a ParsedSource

module Language.Haskell.GHC.ExactPrint.ExactPrint

-- | An AST fragment with an annotation must be able to return the
--   requirements for nesting another one, captured in an <a>Entry</a>, and
--   to be able to use the rest of the exactprint machinery to print the
--   element. In the analogy to Outputable, <a>exact</a> plays the role of
--   <a>ppr</a>.
class Typeable a => ExactPrint a
getAnnotationEntry :: ExactPrint a => a -> Entry
setAnnotationAnchor :: ExactPrint a => a -> Anchor -> [TrailingAnn] -> EpAnnComments -> a
exact :: forall (m :: Type -> Type) w. (ExactPrint a, Monad m, Monoid w) => a -> EP w m a
exactPrint :: ExactPrint ast => ast -> String

-- | The additional option to specify the printing configuration.
exactPrintWithOptions :: (ExactPrint ast, Monoid b, Monad m) => EPOptions m b -> ast -> m (ast, b)

-- | Transform concrete annotations into relative annotations. This should
--   be unnecessary from GHC 9.10
makeDeltaAst :: ExactPrint ast => ast -> ast

-- | The R part of RWS. The environment. Updated via <tt>local</tt> as we
--   enter a new AST element, having a different anchor point.
data EPOptions (m :: Type -> Type) a

-- | Options which can be used to print as a normal String.
stringOptions :: EPOptions Identity String

-- | Helper to create a <a>EPOptions</a>
epOptions :: (String -> m a) -> (String -> m a) -> EPOptions m a

-- | Options which can be used to simply update the AST to be in delta
--   form, without generating output
deltaOptions :: EPOptions Identity ()
instance GHC.Internal.Data.Data.Data Language.Haskell.GHC.ExactPrint.ExactPrint.CanUpdateAnchor
instance GHC.Internal.Data.Data.Data Language.Haskell.GHC.ExactPrint.ExactPrint.HsModuleImpDecls
instance GHC.Classes.Eq Language.Haskell.GHC.ExactPrint.ExactPrint.CanUpdateAnchor
instance GHC.Classes.Eq Language.Haskell.GHC.ExactPrint.ExactPrint.FlushComments
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrintTVFlag (Language.Haskell.Syntax.Type.HsBndrVis GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrintTVFlag GHC.Types.Var.Specificity
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrintTVFlag ()
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.AmbiguousFieldOcc GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.AnnDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Data.BooleanFormula.BooleanFormula (GHC.Parser.Annotation.LocatedN GHC.Types.Name.Reader.RdrName))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Types.ForeignCall.CCallConv
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Types.ForeignCall.CExportSpec
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.ClsInstDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.ConDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.ConDeclField GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint Language.Haskell.GHC.ExactPrint.ExactPrint.DataFamInstDeclWithContext
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.DefaultDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.DerivClauseTys GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.DerivDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.DerivStrategy GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.DocDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.DotFieldOcc GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint body => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.FamEqn GHC.Hs.Extension.GhcPs body)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.FamilyDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Data.FastString.FastString
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.FieldLabelStrings GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.FieldOcc GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.ForeignDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.ForeignExport GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.ForeignImport GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.FunDep GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.GRHS GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.GRHS GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.GRHSs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.GRHSs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedP (GHC.Unit.Module.Warnings.WarningTxt GHC.Hs.Extension.GhcPs))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedP GHC.Types.Basic.OverlapMode)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedC a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedN GHC.Types.Name.Reader.RdrName)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedP GHC.Types.ForeignCall.CType)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.ImpExp.IE GHC.Hs.Extension.GhcPs)])
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.Match GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA body)) => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.Match GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA body))])
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.StmtLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)))])
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Types.SrcLoc.Located a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedE a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedA a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedAn GHC.Parser.Annotation.NoEpAnns a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.StmtLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcPs)))])
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.ConDeclField GHC.Hs.Extension.GhcPs)])
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL (GHC.Data.BooleanFormula.BooleanFormula (GHC.Parser.Annotation.LocatedN GHC.Types.Name.Reader.RdrName)))
instance (Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint tm, Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint ty, GHC.Utils.Outputable.Outputable tm, GHC.Utils.Outputable.Outputable ty) => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsArg GHC.Hs.Extension.GhcPs tm ty)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.HsBind GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.HsCmdTop GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Pat.HsConPatTyArg GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.HsDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.HsDerivingClause GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Hs.DocString.HsDocString
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Hs.DocString.HsDocStringChunk
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint body => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Pat.HsFieldBind (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.FieldOcc GHC.Hs.Extension.GhcPs)) body)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint body => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Pat.HsFieldBind (GHC.Parser.Annotation.LocatedAn GHC.Parser.Annotation.NoEpAnns (Language.Haskell.Syntax.Expr.FieldLabelStrings GHC.Hs.Extension.GhcPs)) body)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedA body) => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Pat.HsFieldBind (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Type.AmbiguousFieldOcc GHC.Hs.Extension.GhcPs)) (GHC.Parser.Annotation.LocatedA body))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsForAllTelescope GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.HsIPBinds GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint Language.Haskell.Syntax.Type.HsIPName
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.HsLocalBinds GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.HsModule GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint Language.Haskell.GHC.ExactPrint.ExactPrint.HsModuleImpDecls
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.HsMultAnn GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrintTVFlag flag => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsOuterTyVarBndrs flag GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Lit.HsOverLit GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsPatSigType GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.HsPragE GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint body => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Pat.HsRecFields GHC.Hs.Extension.GhcPs body)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsScaled GHC.Hs.Extension.GhcPs a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsSigType GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.HsTupArg GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsTyPat GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrintTVFlag flag => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsTyVarBndr flag GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsType GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.HsUntypedSplice GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.HsValBindsLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint body => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Type.HsWildCardBndrs GHC.Hs.Extension.GhcPs body)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.ImpExp.IE GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.ImpExp.IEWrappedName GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.IPBind GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.ImpExp.ImportDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Unit.Module.Warnings.InWarningCategory
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.InjectivityAnn GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.InstDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.LHsRecUpdFields GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint [a]
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.Match GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.Match GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.MatchGroup GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsExpr GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.MatchGroup GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.HsCmd GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Internal.Maybe.Maybe a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint Language.Haskell.Syntax.Module.Name.ModuleName
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Hs.Binds.NamespaceSpecifier
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.ParStmtBlock GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Pat.Pat GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.PatSynBind GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.RecordPatSynField GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint Language.Haskell.Syntax.Basic.Role
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.RoleAnnotDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.RuleBndr GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.RuleDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.RuleDecls GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Types.ForeignCall.Safety
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Binds.Sig GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.SpliceDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.StandaloneKindSig GHC.Hs.Extension.GhcPs)
instance (Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedA (body GHC.Hs.Extension.GhcPs)), Language.Haskell.Syntax.Extension.Anno (Language.Haskell.Syntax.Expr.StmtLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (body GHC.Hs.Extension.GhcPs))) GHC.Types.~ GHC.Parser.Annotation.SrcSpanAnnA, Language.Haskell.Syntax.Extension.Anno [GHC.Types.SrcLoc.GenLocated GHC.Parser.Annotation.SrcSpanAnnA (Language.Haskell.Syntax.Expr.StmtLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (body GHC.Hs.Extension.GhcPs)))] GHC.Types.~ GHC.Parser.Annotation.SrcSpanAnnL, Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Parser.Annotation.LocatedL [GHC.Parser.Annotation.LocatedA (Language.Haskell.Syntax.Expr.StmtLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (body GHC.Hs.Extension.GhcPs)))])) => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Expr.StmtLR GHC.Hs.Extension.GhcPs GHC.Hs.Extension.GhcPs (GHC.Parser.Annotation.LocatedA (body GHC.Hs.Extension.GhcPs)))
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Types.SourceText.StringLiteral
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Types.SourceText.SourceText, GHC.Unit.Module.Warnings.WarningCategory)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Types.SourceText.SourceText, GHC.Types.Basic.RuleName)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.TyClDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.TyFamInstDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint GHC.Internal.Base.Void
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.WarnDecl GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (Language.Haskell.Syntax.Decls.WarnDecls GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint a => Language.Haskell.GHC.ExactPrint.ExactPrint.ExactPrint (GHC.Hs.Doc.WithHsDocIdentifiers a GHC.Hs.Extension.GhcPs)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing a => Language.Haskell.GHC.ExactPrint.ExactPrint.HasEntry (GHC.Parser.Annotation.EpAnn a)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.AddEpAnn
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.AnnContext
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Expr.AnnExplicitSum
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Expr.AnnFieldLabel
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.AnnList
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.AnnListItem
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.AnnParen
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.AnnPragma
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Expr.AnnProjection
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Binds.AnnSig
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Expr.AnnsIf
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.AnnsModule
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Types.Bool
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Expr.EpAnnHsCase
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.ImpExp.EpAnnImportDecl
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Pat.EpAnnSumPat
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.EpaLocation
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Expr.GrhsAnn
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Hs.Decls.HsRuleAnn
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing [GHC.Parser.Annotation.AddEpAnn]
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing (GHC.Internal.Maybe.Maybe GHC.Hs.Expr.EpAnnUnboundVar)
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.NameAnn
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing GHC.Parser.Annotation.NoEpAnns
instance Language.Haskell.GHC.ExactPrint.ExactPrint.HasTrailing (GHC.Parser.Annotation.AddEpAnn, GHC.Parser.Annotation.AddEpAnn)
instance GHC.Internal.Base.Monoid w => GHC.Internal.Base.Monoid (Language.Haskell.GHC.ExactPrint.ExactPrint.EPWriter w)
instance GHC.Internal.Base.Monoid w => GHC.Internal.Base.Semigroup (Language.Haskell.GHC.ExactPrint.ExactPrint.EPWriter w)
instance GHC.Internal.Show.Show Language.Haskell.GHC.ExactPrint.ExactPrint.CanUpdateAnchor
instance GHC.Internal.Show.Show Language.Haskell.GHC.ExactPrint.ExactPrint.FlushComments


-- | <tt>ghc-exactprint</tt> is a library to manage manipulating Haskell
--   source files. There are four components.
module Language.Haskell.GHC.ExactPrint

-- | A Haskell comment. The <tt>AnnKeywordId</tt> is present if it has been
--   converted from an <tt>AnnKeywordId</tt> because the annotation must be
--   interleaved into the stream and does not have a well-defined position
data Comment

-- | This entry point will also work out which language extensions are
--   required and perform CPP processing if necessary.
--   
--   <pre>
--   parseModule = parseModuleWithCpp defaultCppOptions
--   </pre>
--   
--   Note: <a>ParsedSource</a> is a synonym for <a>Located</a>
--   (<a>HsModule</a> <tt>GhcPs</tt>)
parseModule :: LibDir -> FilePath -> IO (ParseResult ParsedSource)

-- | An AST fragment with an annotation must be able to return the
--   requirements for nesting another one, captured in an <a>Entry</a>, and
--   to be able to use the rest of the exactprint machinery to print the
--   element. In the analogy to Outputable, <a>exact</a> plays the role of
--   <a>ppr</a>.
class Typeable a => ExactPrint a
getAnnotationEntry :: ExactPrint a => a -> Entry
setAnnotationAnchor :: ExactPrint a => a -> Anchor -> [TrailingAnn] -> EpAnnComments -> a
exact :: forall (m :: Type -> Type) w. (ExactPrint a, Monad m, Monoid w) => a -> EP w m a
exactPrint :: ExactPrint ast => ast -> String

-- | Transform concrete annotations into relative annotations. This should
--   be unnecessary from GHC 9.10
makeDeltaAst :: ExactPrint ast => ast -> ast
