Safe Haskell	None
Language	Haskell2010

Retrie.ExactPrint

Contents

Fixity re-association
Parsers
Primitive Transformations
Utils
Annotated AST
ghc-exactprint re-exports

Description

Provides consistent interface with ghc-exactprint.

Synopsis

fix :: (Data ast, Monad m) => FixityEnv -> ast -> TransformT m ast
parseContent :: FixityEnv -> FilePath -> String -> IO AnnotatedModule
parseContentNoFixity :: FilePath -> String -> IO AnnotatedModule
parseDecl :: String -> IO AnnotatedHsDecl
parseExpr :: String -> IO AnnotatedHsExpr
parseImports :: [String] -> IO AnnotatedImports
parsePattern :: String -> IO AnnotatedPat
parseStmt :: String -> IO AnnotatedStmt
parseType :: String -> IO AnnotatedHsType
addAllAnnsT :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m ()
cloneT :: (Data a, Typeable a, Monad m) => a -> TransformT m a
setEntryDPT :: (Data a, Monad m) => Located a -> DeltaPos -> TransformT m ()
swapEntryDPT :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m ()
transferAnnsT :: (Data a, Data b, Monad m) => (KeywordId -> Bool) -> Located a -> Located b -> TransformT m ()
transferEntryAnnsT :: (Data a, Data b, Monad m) => (KeywordId -> Bool) -> Located a -> Located b -> TransformT m ()
transferEntryDPT :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m ()
debugDump :: Annotate a => Annotated (Located a) -> IO ()
debugParse :: FixityEnv -> String -> IO ()
hasComments :: (Data a, Monad m) => Located a -> TransformT m Bool
isComma :: KeywordId -> Bool
module Retrie.ExactPrint.Annotated
parseModule :: FilePath -> IO (ParseResult ParsedSource)
relativiseApiAnnsWithComments :: Annotate ast => [Comment] -> Located ast -> ApiAnns -> Anns
relativiseApiAnns :: Annotate ast => Located ast -> ApiAnns -> Anns
addAnnotationsForPretty :: Annotate a => [Comment] -> Located a -> Anns -> Anns
exactPrint :: Annotate ast => Located ast -> Anns -> String
modifyDeclsT :: (HasDecls t, HasTransform m) => ([LHsDecl GhcPs] -> m [LHsDecl GhcPs]) -> t -> m t
modifyValD :: HasTransform m => SrcSpan -> Decl -> (Match -> [Decl] -> m ([Decl], Maybe t)) -> m (Decl, Maybe t)
replaceDeclsValbinds :: Monad m => HsLocalBinds GhcPs -> [LHsDecl GhcPs] -> TransformT m (HsLocalBinds GhcPs)
hsDeclsValBinds :: Monad m => HsLocalBinds GhcPs -> TransformT m [LHsDecl GhcPs]
hsDeclsGeneric :: (Data t, Monad m) => t -> TransformT m [LHsDecl GhcPs]
hasDeclsSybTransform :: (Data t2, Monad m) => (forall t. HasDecls t => t -> m t) -> (LHsBind GhcPs -> m (LHsBind GhcPs)) -> t2 -> m t2
replaceDeclsPatBind :: Monad m => LHsBind GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsBind GhcPs)
replaceDeclsPatBindD :: Monad m => LHsDecl GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsDecl GhcPs)
hsDeclsPatBind :: Monad m => LHsBind GhcPs -> TransformT m [LHsDecl GhcPs]
hsDeclsPatBindD :: Monad m => LHsDecl GhcPs -> TransformT m [LHsDecl GhcPs]
insertBefore :: HasDecls (Located ast) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast)
insertAfter :: HasDecls (Located ast) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast)
insertAtEnd :: HasDecls (Located ast) => Located ast -> LHsDecl GhcPs -> Transform (Located ast)
insertAtStart :: HasDecls (Located ast) => Located ast -> LHsDecl GhcPs -> Transform (Located ast)
moveTrailingComments :: (Data a, Data b) => Located a -> Located b -> Transform ()
balanceTrailingComments :: (Monad m, Data a, Data b) => Located a -> Located b -> TransformT m [(Comment, DeltaPos)]
balanceComments :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m ()
addTrailingComma :: Data a => Located a -> DeltaPos -> Anns -> Anns
getEntryDP :: Data a => Anns -> Located a -> DeltaPos
setPrecedingLines :: Data a => Located a -> Int -> Int -> Anns -> Anns
setPrecedingLinesDecl :: LHsDecl GhcPs -> Int -> Int -> Anns -> Anns
mergeAnnList :: [Anns] -> Anns
mergeAnns :: Anns -> Anns -> Anns
setPrecedingLinesT :: (Data a, Monad m) => Located a -> Int -> Int -> TransformT m ()
setPrecedingLinesDeclT :: Monad m => LHsDecl GhcPs -> Int -> Int -> TransformT m ()
getEntryDPT :: (Data a, Monad m) => Located a -> TransformT m DeltaPos
removeTrailingCommaT :: (Data a, Monad m) => Located a -> TransformT m ()
addTrailingCommaT :: (Data a, Monad m) => Located a -> TransformT m ()
addSimpleAnnT :: (Constraints a, Monad m) => Located a -> DeltaPos -> [(KeywordId, DeltaPos)] -> TransformT m ()
wrapDecl :: LHsBind GhcPs -> LHsDecl GhcPs
wrapSig :: LSig GhcPs -> LHsDecl GhcPs
decl2Sig :: LHsDecl name -> [LSig name]
decl2Bind :: LHsDecl name -> [LHsBind name]
captureOrderAnnKey :: AnnKey -> [Located b] -> Anns -> Anns
captureOrder :: Data a => Located a -> [Located b] -> Anns -> Anns
graftT :: (Data a, Monad m) => Anns -> a -> TransformT m a
isUniqueSrcSpan :: SrcSpan -> Bool
uniqueSrcSpanT :: Monad m => TransformT m SrcSpan
modifyAnnsT :: Monad m => (Anns -> Anns) -> TransformT m ()
putAnnsT :: Monad m => Anns -> TransformT m ()
getAnnsT :: Monad m => TransformT m Anns
logDataWithAnnsTr :: (Monad m, Data a) => String -> a -> TransformT m ()
logTr :: Monad m => String -> TransformT m ()
hoistTransform :: (forall x. m x -> n x) -> TransformT m a -> TransformT n a
runTransformFromT :: Int -> Anns -> TransformT m a -> m (a, (Anns, Int), [String])
runTransformFrom :: Int -> Anns -> Transform a -> (a, (Anns, Int), [String])
runTransformT :: Anns -> TransformT m a -> m (a, (Anns, Int), [String])
runTransform :: Anns -> Transform a -> (a, (Anns, Int), [String])
type Transform = TransformT Identity
newtype TransformT (m :: Type -> Type) a = TransformT {
- unTransformT :: RWST () [String] (Anns, Int) m a
}
class Data t => HasDecls t where
- hsDecls :: Monad m => t -> TransformT m [LHsDecl GhcPs]
- replaceDecls :: Monad m => t -> [LHsDecl GhcPs] -> TransformT m t
class Monad m => HasTransform (m :: Type -> Type) where
- liftT :: Transform a -> m a
data Comment
data Annotation = Ann {
- annEntryDelta :: !DeltaPos
- annPriorComments :: ![(Comment, DeltaPos)]
- annFollowingComments :: ![(Comment, DeltaPos)]
- annsDP :: ![(KeywordId, DeltaPos)]
- annSortKey :: !(Maybe [SrcSpan])
- annCapturedSpan :: !(Maybe AnnKey)
}
type Anns = Map AnnKey Annotation
data AnnKey = AnnKey SrcSpan AnnConName
class Data ast => Annotate ast
annGetConstr :: Data a => a -> AnnConName
mkAnnKey :: Data a => Located a -> AnnKey
emptyAnns :: Anns
annNone :: Annotation
newtype DeltaPos = DP (Int, Int)
data AnnConName = CN {
- unConName :: String
}
data KeywordId
- = G AnnKeywordId
- | AnnSemiSep
- | AnnTypeApp
- | AnnComment Comment
- | AnnString String
annLeadingCommentEntryDelta :: Annotation -> DeltaPos
showGhc :: Outputable a => a -> String

Fixity re-association

fix :: (Data ast, Monad m) => FixityEnv -> ast -> TransformT m ast Source #

Re-associate AST using given FixityEnv. (The GHC parser has no knowledge of operator fixity, because that requires running the renamer, so it parses all operators as left-associated.)

Parsers

parseContent :: FixityEnv -> FilePath -> String -> IO AnnotatedModule Source #

parseContentNoFixity :: FilePath -> String -> IO AnnotatedModule Source #

parseDecl :: String -> IO AnnotatedHsDecl Source #

Parse a top-level HsDecl.

parseExpr :: String -> IO AnnotatedHsExpr Source #

Parse a HsExpr.

parseImports :: [String] -> IO AnnotatedImports Source #

Parse import statements. Each string must be a full import statement, including the keyword 'import'. Supports full import syntax.

parsePattern :: String -> IO AnnotatedPat Source #

Parse a Pat.

parseStmt :: String -> IO AnnotatedStmt Source #

Parse a Stmt.

parseType :: String -> IO AnnotatedHsType Source #

Parse a HsType.

Primitive Transformations

addAllAnnsT :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m () Source #

cloneT :: (Data a, Typeable a, Monad m) => a -> TransformT m a Source #

setEntryDPT :: (Data a, Monad m) => Located a -> DeltaPos -> TransformT m () Source #

Transform monad version of getEntryDP

swapEntryDPT :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m () Source #

transferAnnsT :: (Data a, Data b, Monad m) => (KeywordId -> Bool) -> Located a -> Located b -> TransformT m () Source #

transferEntryAnnsT :: (Data a, Data b, Monad m) => (KeywordId -> Bool) -> Located a -> Located b -> TransformT m () Source #

transferEntryDPT :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m () Source #

Transform monad version of transferEntryDP

Utils

debugDump :: Annotate a => Annotated (Located a) -> IO () Source #

debugParse :: FixityEnv -> String -> IO () Source #

hasComments :: (Data a, Monad m) => Located a -> TransformT m Bool Source #

isComma :: KeywordId -> Bool Source #

Annotated AST

module Retrie.ExactPrint.Annotated

ghc-exactprint re-exports

parseModule :: FilePath -> IO (ParseResult ParsedSource) #

This entry point will also work out which language extensions are required and perform CPP processing if necessary.

parseModule = parseModuleWithCpp defaultCppOptions

Note: ParsedSource is a synonym for Located (HsModule GhcPs)

relativiseApiAnnsWithComments :: Annotate ast => [Comment] -> Located ast -> ApiAnns -> Anns #

Exactly the same as relativiseApiAnns but with the possibilty to inject comments. This is typically used if the source has been preprocessed by e.g. CPP, and the parts stripped out of the original source are re-added as comments so they are not lost for round tripping.

relativiseApiAnns :: Annotate ast => Located ast -> ApiAnns -> Anns #

Transform concrete annotations into relative annotations which are more useful when transforming an AST.

addAnnotationsForPretty :: Annotate a => [Comment] -> Located a -> Anns -> Anns #

Add any missing annotations so that the full AST element will exactprint properly when done.

exactPrint :: Annotate ast => Located ast -> Anns -> String #

Print an AST with a map of potential modified Anns. The usual way to generate such a map is by using one of the parsers in Language.Haskell.GHC.ExactPrint.Parsers.

modifyDeclsT :: (HasDecls t, HasTransform m) => ([LHsDecl GhcPs] -> m [LHsDecl GhcPs]) -> t -> m t #

Apply a transformation to the decls contained in t

modifyValD :: HasTransform m => SrcSpan -> Decl -> (Match -> [Decl] -> m ([Decl], Maybe t)) -> m (Decl, Maybe t) #

Modify a LHsBind wrapped in a ValD. For a PatBind the declarations are extracted and returned after modification. For a FunBind the supplied SrcSpan is used to identify the specific Match to be transformed, for when there are multiple of them.

replaceDeclsValbinds :: Monad m => HsLocalBinds GhcPs -> [LHsDecl GhcPs] -> TransformT m (HsLocalBinds GhcPs) #

Utility function for returning decls to HsLocalBinds. Use with care, as this does not manage the declaration order, the ordering should be done by the calling function from the HsLocalBinds context in the AST.

hsDeclsValBinds :: Monad m => HsLocalBinds GhcPs -> TransformT m [LHsDecl GhcPs] #

Utility function for extracting decls from HsLocalBinds. Use with care, as this does not necessarily return the declarations in order, the ordering should be done by the calling function from the HsLocalBinds context in the AST.

hsDeclsGeneric :: (Data t, Monad m) => t -> TransformT m [LHsDecl GhcPs] #

A FunBind wraps up one or more Match items. hsDecls cannot return anything for these as there is not meaningful replaceDecls for it. This function provides a version of hsDecls that returns the FunBind decls too, where they are needed for analysis only.

hasDeclsSybTransform #

Arguments

:: (Data t2, Monad m)
=> (forall t. HasDecls t => t -> m t)	Worker function for the general case
-> (LHsBind GhcPs -> m (LHsBind GhcPs))	Worker function for FunBind/PatBind
-> t2	Item to be updated
-> m t2

Do a transformation on an AST fragment by providing a function to process the general case and one specific for a LHsBind. This is required because a FunBind may have multiple Match items, so we cannot gurantee that replaceDecls after hsDecls is idempotent.

replaceDeclsPatBind :: Monad m => LHsBind GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsBind GhcPs) #

Replace the immediate declarations for a PatBind. This cannot be a member of HasDecls because a FunBind is not idempotent for hsDecls / replaceDecls. hsDeclsPatBind / replaceDeclsPatBind is idempotent.

replaceDeclsPatBindD :: Monad m => LHsDecl GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsDecl GhcPs) #

Replace the immediate declarations for a PatBind wrapped in a ValD. This cannot be a member of HasDecls because a FunBind is not idempotent for hsDecls / replaceDecls. hsDeclsPatBindD / replaceDeclsPatBindD is idempotent.

hsDeclsPatBind :: Monad m => LHsBind GhcPs -> TransformT m [LHsDecl GhcPs] #

Extract the immediate declarations for a PatBind. This cannot be a member of HasDecls because a FunBind is not idempotent for hsDecls / replaceDecls. hsDeclsPatBind / replaceDeclsPatBind is idempotent.

hsDeclsPatBindD :: Monad m => LHsDecl GhcPs -> TransformT m [LHsDecl GhcPs] #

Extract the immediate declarations for a PatBind wrapped in a ValD. This cannot be a member of HasDecls because a FunBind is not idempotent for hsDecls / replaceDecls. hsDeclsPatBindD / replaceDeclsPatBindD is idempotent.

insertBefore :: HasDecls (Located ast) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast) #

Insert a declaration at a specific location in the subdecls of the given AST item

insertAfter :: HasDecls (Located ast) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast) #

Insert a declaration at a specific location in the subdecls of the given AST item

insertAtEnd :: HasDecls (Located ast) => Located ast -> LHsDecl GhcPs -> Transform (Located ast) #

Insert a declaration at the beginning or end of the subdecls of the given AST item

insertAtStart :: HasDecls (Located ast) => Located ast -> LHsDecl GhcPs -> Transform (Located ast) #

Insert a declaration at the beginning or end of the subdecls of the given AST item

moveTrailingComments :: (Data a, Data b) => Located a -> Located b -> Transform () #

Move any annFollowingComments values from the Annotation associated to the first parameter to that of the second.

balanceTrailingComments :: (Monad m, Data a, Data b) => Located a -> Located b -> TransformT m [(Comment, DeltaPos)] #

After moving an AST element, make sure any comments that may belong with the following element in fact do. Of necessity this is a heuristic process, to be tuned later. Possibly a variant should be provided with a passed-in decision function.

balanceComments :: (Data a, Data b, Monad m) => Located a -> Located b -> TransformT m () #

The relatavise phase puts all comments appearing between the end of one AST item and the beginning of the next as annPriorComments for the second one. This function takes two adjacent AST items and moves any annPriorComments from the second one to the annFollowingComments of the first if they belong to it instead. This is typically required before deleting or duplicating either of the AST elements.

addTrailingComma :: Data a => Located a -> DeltaPos -> Anns -> Anns #

getEntryDP :: Data a => Anns -> Located a -> DeltaPos #

Return the true entry DeltaPos from the annotation for a given AST element. This is the DeltaPos ignoring any comments.

setPrecedingLines :: Data a => Located a -> Int -> Int -> Anns -> Anns #

Adjust the entry annotations to provide an n line preceding gap

setPrecedingLinesDecl :: LHsDecl GhcPs -> Int -> Int -> Anns -> Anns #

Unwrap a HsDecl and call setPrecedingLines on it ++AZ++ TODO: get rid of this, it is a synonym only

mergeAnnList :: [Anns] -> Anns #

Combine a list of annotations

mergeAnns :: Anns -> Anns -> Anns #

Left bias pair union

setPrecedingLinesT :: (Data a, Monad m) => Located a -> Int -> Int -> TransformT m () #

Transform monad version of setPrecedingLines

setPrecedingLinesDeclT :: Monad m => LHsDecl GhcPs -> Int -> Int -> TransformT m () #

Transform monad version of setPrecedingLinesDecl

getEntryDPT :: (Data a, Monad m) => Located a -> TransformT m DeltaPos #

Transform monad version of getEntryDP

removeTrailingCommaT :: (Data a, Monad m) => Located a -> TransformT m () #

Remove a trailing comma annotation, if there is one one

addTrailingCommaT :: (Data a, Monad m) => Located a -> TransformT m () #

Add a trailing comma annotation, unless there is already one

addSimpleAnnT :: (Constraints a, Monad m) => Located a -> DeltaPos -> [(KeywordId, DeltaPos)] -> TransformT m () #

Create a simple Annotation without comments, and attach it to the first parameter.

wrapDecl :: LHsBind GhcPs -> LHsDecl GhcPs #

Convert a LHsBind into a LHsDecl

wrapSig :: LSig GhcPs -> LHsDecl GhcPs #

Convert a LSig into a LHsDecl

decl2Sig :: LHsDecl name -> [LSig name] #

Pure function to convert a LSig to a LHsBind. This does nothing to any annotations that may be attached to either of the elements. It is used as a utility function in replaceDecls

decl2Bind :: LHsDecl name -> [LHsBind name] #

Pure function to convert a LHsDecl to a LHsBind. This does nothing to any annotations that may be attached to either of the elements. It is used as a utility function in replaceDecls

captureOrderAnnKey :: AnnKey -> [Located b] -> Anns -> Anns #

If a list has been re-ordered or had items added, capture the new order in the appropriate annSortKey item of the supplied AnnKey

captureOrder :: Data a => Located a -> [Located b] -> Anns -> Anns #

If a list has been re-ordered or had items added, capture the new order in the appropriate annSortKey attached to the Annotation for the first parameter.

graftT :: (Data a, Monad m) => Anns -> a -> TransformT m a #

Slightly more general form of cloneT

isUniqueSrcSpan :: SrcSpan -> Bool #

Test whether a given SrcSpan was generated by uniqueSrcSpanT

uniqueSrcSpanT :: Monad m => TransformT m SrcSpan #

Once we have Anns, a SrcSpan is used purely as part of an AnnKey to index into the Anns. If we need to add new elements to the AST, they need their own SrcSpan for this.

modifyAnnsT :: Monad m => (Anns -> Anns) -> TransformT m () #

Change the stored Anns

putAnnsT :: Monad m => Anns -> TransformT m () #

Replace the Anns after any changes

getAnnsT :: Monad m => TransformT m Anns #

Access the Anns being modified in this transformation

logDataWithAnnsTr :: (Monad m, Data a) => String -> a -> TransformT m () #

Log a representation of the given AST with annotations to the output of the Monad

logTr :: Monad m => String -> TransformT m () #

Log a string to the output of the Monad

hoistTransform :: (forall x. m x -> n x) -> TransformT m a -> TransformT n a #

Change inner monad of TransformT.

runTransformFromT :: Int -> Anns -> TransformT m a -> m (a, (Anns, Int), [String]) #

Run a monad transformer stack for the TransformT monad transformer

runTransformFrom :: Int -> Anns -> Transform a -> (a, (Anns, Int), [String]) #

Run a transformation in the Transform monad, returning the updated annotations and any logging generated via logTr, allocating any new SrcSpans from the provided initial value.

runTransformT :: Anns -> TransformT m a -> m (a, (Anns, Int), [String]) #

runTransform :: Anns -> Transform a -> (a, (Anns, Int), [String]) #

Run a transformation in the Transform monad, returning the updated annotations and any logging generated via logTr

type Transform = TransformT Identity #

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.

newtype TransformT (m :: Type -> Type) a #

Monad transformer version of Transform monad

Constructors

TransformT
Fields unTransformT :: RWST () [String] (Anns, Int) m a

Instances

MonadTrans TransformT
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods lift :: Monad m => m a -> TransformT m a #
Monad m => MonadReader () (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods ask :: TransformT m () # local :: (() -> ()) -> TransformT m a -> TransformT m a # reader :: (() -> a) -> TransformT m a #
Monad m => Monad (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods (>>=) :: TransformT m a -> (a -> TransformT m b) -> TransformT m b # (>>) :: TransformT m a -> TransformT m b -> TransformT m b # return :: a -> TransformT m a # fail :: String -> TransformT m a #
Functor m => Functor (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods fmap :: (a -> b) -> TransformT m a -> TransformT m b # (<$) :: a -> TransformT m b -> TransformT m a #
MonadFail m => MonadFail (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods fail :: String -> TransformT m a #
Monad m => Applicative (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods pure :: a -> TransformT m a # (<>) :: TransformT m (a -> b) -> TransformT m a -> TransformT m b # liftA2 :: (a -> b -> c) -> TransformT m a -> TransformT m b -> TransformT m c # (>) :: TransformT m a -> TransformT m b -> TransformT m b # (<*) :: TransformT m a -> TransformT m b -> TransformT m a #
Monad m => HasTransform (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods liftT :: Transform a -> TransformT m a #
Monad m => MonadWriter [String] (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods writer :: (a, [String]) -> TransformT m a # tell :: [String] -> TransformT m () # listen :: TransformT m a -> TransformT m (a, [String]) # pass :: TransformT m (a, [String] -> [String]) -> TransformT m a #
Monad m => MonadState (Anns, Int) (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods get :: TransformT m (Anns, Int) # put :: (Anns, Int) -> TransformT m () # state :: ((Anns, Int) -> (a, (Anns, Int))) -> TransformT m a #

class Data t => HasDecls t where #

Provide a means to get and process the immediate child declartions of a given AST element.

Methods

hsDecls :: Monad m => t -> TransformT m [LHsDecl GhcPs] #

Return the HsDecls that are directly enclosed in the given syntax phrase. They are always returned in the wrapped HsDecl form, even if orginating in local decls. This is safe, as annotations never attach to the wrapper, only to the wrapped item.

replaceDecls :: Monad m => t -> [LHsDecl GhcPs] -> TransformT m t #

Replace the directly enclosed decl list by the given decl list. Runs in the Transform monad to be able to update list order annotations, and rebalance comments and other layout changes as needed.

For example, a call on replaceDecls for a wrapped FunBind having no where clause will convert

-- |This is a function
foo = x -- comment1

in to

-- |This is a function
foo = x -- comment1
  where
    nn = 2

Instances

HasDecls ParsedSource
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: Monad m => ParsedSource -> TransformT m [LHsDecl GhcPs] # replaceDecls :: Monad m => ParsedSource -> [LHsDecl GhcPs] -> TransformT m ParsedSource #
HasDecls (LHsExpr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: Monad m => LHsExpr GhcPs -> TransformT m [LHsDecl GhcPs] # replaceDecls :: Monad m => LHsExpr GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsExpr GhcPs) #
HasDecls (LMatch GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: Monad m => LMatch GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: Monad m => LMatch GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LMatch GhcPs (LHsExpr GhcPs)) #
HasDecls (LStmt GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: Monad m => LStmt GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: Monad m => LStmt GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LStmt GhcPs (LHsExpr GhcPs)) #

class Monad m => HasTransform (m :: Type -> Type) where #

Used to integrate a Transform into other Monad stacks

Methods

liftT :: Transform a -> m a #

Instances

Monad m => HasTransform (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods liftT :: Transform a -> TransformT m a #

data Comment #

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

Instances

Eq Comment
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods (==) :: Comment -> Comment -> Bool # (/=) :: Comment -> Comment -> Bool #
Data Comment
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Comment -> c Comment # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Comment # toConstr :: Comment -> Constr # dataTypeOf :: Comment -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Comment) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment) # gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Comment -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Comment -> r # gmapQ :: (forall d. Data d => d -> u) -> Comment -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Comment -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Comment -> m Comment # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Comment -> m Comment # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Comment -> m Comment #
Ord Comment
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods compare :: Comment -> Comment -> Ordering # (<) :: Comment -> Comment -> Bool # (<=) :: Comment -> Comment -> Bool # (>) :: Comment -> Comment -> Bool # (>=) :: Comment -> Comment -> Bool # max :: Comment -> Comment -> Comment # min :: Comment -> Comment -> Comment #
Show Comment
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods showsPrec :: Int -> Comment -> ShowS # show :: Comment -> String # showList :: [Comment] -> ShowS #
Outputable Comment
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods ppr :: Comment -> SDoc # pprPrec :: Rational -> Comment -> SDoc #

data Annotation #

Constructors

Ann

Fields

annEntryDelta :: !DeltaPos
Offset used to get to the start of the SrcSpan, from whatever the prior output was, including all annPriorComments (field below).
annPriorComments :: ![(Comment, DeltaPos)]
Comments coming after the last non-comment output of the preceding element but before the SrcSpan being annotated by this Annotation. If these are changed then annEntryDelta (field above) must also change to match.
annFollowingComments :: ![(Comment, DeltaPos)]
Comments coming after the last output for the element subject to this Annotation. These will only be added by AST transformations, and care must be taken not to disturb layout of following elements.
annsDP :: ![(KeywordId, DeltaPos)]
Annotations associated with this element.
annSortKey :: !(Maybe [SrcSpan])
Captures the sort order of sub elements. This is needed when the sub-elements have been split (as in a HsLocalBind which holds separate binds and sigs) or for infix patterns where the order has been re-arranged. It is captured explicitly so that after the Delta phase a SrcSpan is used purely as an index into the annotations, allowing transformations of the AST including the introduction of new Located items or re-arranging existing ones.
annCapturedSpan :: !(Maybe AnnKey)
Occasionally we must calculate a SrcSpan for an unlocated list of elements which we must remember for the Print phase. e.g. the statements in a HsLet or HsDo. These must be managed as a group because they all need eo be vertically aligned for the Haskell layout rules, and this guarantees this property in the presence of AST edits.

Instances

Eq Annotation
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods (==) :: Annotation -> Annotation -> Bool # (/=) :: Annotation -> Annotation -> Bool #
Show Annotation
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods showsPrec :: Int -> Annotation -> ShowS # show :: Annotation -> String # showList :: [Annotation] -> ShowS #
Outputable Annotation
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods ppr :: Annotation -> SDoc # pprPrec :: Rational -> Annotation -> SDoc #
Monad m => MonadState (Anns, Int) (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods get :: TransformT m (Anns, Int) # put :: (Anns, Int) -> TransformT m () # state :: ((Anns, Int) -> (a, (Anns, Int))) -> TransformT m a #

type Anns = Map AnnKey Annotation #

This structure holds a complete set of annotations for an AST

data AnnKey #

For every Located a, use the SrcSpan and constructor name of a as the key, to store the standard annotation. These are used to maintain context in the AP and EP monads

Constructors

AnnKey SrcSpan AnnConName

Instances

Eq AnnKey
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods (==) :: AnnKey -> AnnKey -> Bool # (/=) :: AnnKey -> AnnKey -> Bool #
Data AnnKey
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnKey -> c AnnKey # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnKey # toConstr :: AnnKey -> Constr # dataTypeOf :: AnnKey -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnKey) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnKey) # gmapT :: (forall b. Data b => b -> b) -> AnnKey -> AnnKey # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnKey -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnKey -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnKey -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnKey -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnKey -> m AnnKey # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKey -> m AnnKey # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKey -> m AnnKey #
Ord AnnKey
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods compare :: AnnKey -> AnnKey -> Ordering # (<) :: AnnKey -> AnnKey -> Bool # (<=) :: AnnKey -> AnnKey -> Bool # (>) :: AnnKey -> AnnKey -> Bool # (>=) :: AnnKey -> AnnKey -> Bool # max :: AnnKey -> AnnKey -> AnnKey # min :: AnnKey -> AnnKey -> AnnKey #
Show AnnKey
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods showsPrec :: Int -> AnnKey -> ShowS # show :: AnnKey -> String # showList :: [AnnKey] -> ShowS #
Outputable AnnKey
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods ppr :: AnnKey -> SDoc # pprPrec :: Rational -> AnnKey -> SDoc #
Monad m => MonadState (Anns, Int) (TransformT m)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods get :: TransformT m (Anns, Int) # put :: (Anns, Int) -> TransformT m () # state :: ((Anns, Int) -> (a, (Anns, Int))) -> TransformT m a #

class Data ast => Annotate ast #

Minimal complete definition

markAST

Instances

Annotate DocDecl
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DocDecl -> Annotated () #
Annotate HsIPName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsIPName -> Annotated () #
Annotate RdrName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RdrName -> Annotated () #
Annotate HsDocString
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDocString -> Annotated () #
Annotate Safety
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Safety -> Annotated () #
Annotate CExportSpec
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> CExportSpec -> Annotated () #
Annotate CCallConv
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> CCallConv -> Annotated () #
Annotate CType
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> CType -> Annotated () #
Annotate StringLiteral
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> StringLiteral -> Annotated () #
Annotate WarningTxt
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarningTxt -> Annotated () #
Annotate OverlapMode
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> OverlapMode -> Annotated () #
Annotate ModuleName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ModuleName -> Annotated () #
Annotate FastString
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FastString -> Annotated () #
Annotate ResTyGADTHook
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ResTyGADTHook -> Annotated () #
Annotate WildCardAnon
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WildCardAnon -> Annotated () #
Annotate [ExprLStmt GhcPs]	Used for declarations that need to be aligned together, e.g. in a do or let .. in statement/expr
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [ExprLStmt GhcPs] -> Annotated () #
Annotate [LHsDerivingClause GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsDerivingClause GhcPs] -> Annotated () #
Annotate [LHsType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsType GhcPs] -> Annotated () #
Annotate [LHsSigType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsSigType GhcPs] -> Annotated () #
Annotate [LConDeclField GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LConDeclField GhcPs] -> Annotated () #
Annotate [LIE GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LIE GhcPs] -> Annotated () #
Annotate body => Annotate [Located (Match GhcPs (Located body))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (Match GhcPs (Located body))] -> Annotated () #
Annotate [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))] -> Annotated () #
Annotate (Maybe Role)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Maybe Role -> Annotated () #
Annotate (HsModule GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsModule GhcPs -> Annotated () #
Annotate (HsTupArg GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsTupArg GhcPs -> Annotated () #
Annotate (HsCmdTop GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsCmdTop GhcPs -> Annotated () #
Annotate (HsDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDecl GhcPs -> Annotated () #
Annotate (SpliceDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> SpliceDecl GhcPs -> Annotated () #
Annotate (TyClDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyClDecl GhcPs -> Annotated () #
Annotate (FamilyResultSig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FamilyResultSig GhcPs -> Annotated () #
Annotate (FamilyDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FamilyDecl GhcPs -> Annotated () #
Annotate (InjectivityAnn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> InjectivityAnn GhcPs -> Annotated () #
Annotate (HsDerivingClause GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDerivingClause GhcPs -> Annotated () #
Annotate (ConDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ConDecl GhcPs -> Annotated () #
Annotate (TyFamInstEqn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstEqn GhcPs -> Annotated () #
Annotate (TyFamDefltEqn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamDefltEqn GhcPs -> Annotated () #
Annotate (TyFamInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstDecl GhcPs -> Annotated () #
Annotate (DataFamInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DataFamInstDecl GhcPs -> Annotated () #
Annotate (ClsInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ClsInstDecl GhcPs -> Annotated () #
Annotate (InstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> InstDecl GhcPs -> Annotated () #
Annotate (DerivDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DerivDecl GhcPs -> Annotated () #
Annotate (DerivStrategy GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DerivStrategy GhcPs -> Annotated () #
Annotate (DefaultDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DefaultDecl GhcPs -> Annotated () #
Annotate (ForeignDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ForeignDecl GhcPs -> Annotated () #
Annotate (RuleDecls GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleDecls GhcPs -> Annotated () #
Annotate (RuleDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleDecl GhcPs -> Annotated () #
Annotate (RuleBndr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleBndr GhcPs -> Annotated () #
Annotate (WarnDecls GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarnDecls GhcPs -> Annotated () #
Annotate (WarnDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarnDecl GhcPs -> Annotated () #
Annotate (AnnDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> AnnDecl GhcPs -> Annotated () #
Annotate (RoleAnnotDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RoleAnnotDecl GhcPs -> Annotated () #
Annotate (HsRecUpdField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecUpdField GhcPs -> Annotated () #
Annotate (HsLocalBinds GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsLocalBinds GhcPs -> Annotated () #
Annotate (HsBind GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsBind GhcPs -> Annotated () #
Annotate (IPBind GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IPBind GhcPs -> Annotated () #
Annotate (Sig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Sig GhcPs -> Annotated () #
Annotate (HsTyVarBndr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsTyVarBndr GhcPs -> Annotated () #
Annotate (HsType GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsType GhcPs -> Annotated () #
Annotate (ConDeclField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ConDeclField GhcPs -> Annotated () #
Annotate (FieldOcc GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FieldOcc GhcPs -> Annotated () #
Annotate (AmbiguousFieldOcc GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> AmbiguousFieldOcc GhcPs -> Annotated () #
Annotate (HsLit GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsLit GhcPs -> Annotated () #
Annotate (HsOverLit GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsOverLit GhcPs -> Annotated () #
Annotate (FunDep (Located RdrName))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FunDep (Located RdrName) -> Annotated () #
Annotate (HsExpr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsExpr GhcPs -> Annotated () #
Annotate (HsCmd GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsCmd GhcPs -> Annotated () #
Annotate (HsSplice GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsSplice GhcPs -> Annotated () #
Annotate (ImportDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ImportDecl GhcPs -> Annotated () #
Annotate (IEWrappedName RdrName)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IEWrappedName RdrName -> Annotated () #
Annotate (IE GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IE GhcPs -> Annotated () #
Annotate (Pat GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Pat GhcPs -> Annotated () #
Annotate name => Annotate (BooleanFormula (Located name))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> BooleanFormula (Located name) -> Annotated () #
Annotate (SourceText, FastString)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> (SourceText, FastString) -> Annotated () #
Annotate body => Annotate (Match GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Match GhcPs (Located body) -> Annotated () #
Annotate body => Annotate (GRHS GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> GRHS GhcPs (Located body) -> Annotated () #
Annotate body => Annotate (Stmt GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Stmt GhcPs (Located body) -> Annotated () #
Annotate (ParStmtBlock GhcPs GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ParStmtBlock GhcPs GhcPs -> Annotated () #
Annotate (HsRecField GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (LHsExpr GhcPs) -> Annotated () #
Annotate (HsRecField GhcPs (LPat GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (LPat GhcPs) -> Annotated () #
Annotate arg => Annotate (HsImplicitBndrs GhcPs (Located arg))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsImplicitBndrs GhcPs (Located arg) -> Annotated () #

annGetConstr :: Data a => a -> AnnConName #

mkAnnKey :: Data a => Located a -> AnnKey #

Make an unwrapped AnnKey for the LHsDecl case, a normal one otherwise.

emptyAnns :: Anns #

annNone :: Annotation #

newtype DeltaPos #

A relative positions, row then column

Constructors

DP (Int, Int)

Instances

Eq DeltaPos
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods (==) :: DeltaPos -> DeltaPos -> Bool # (/=) :: DeltaPos -> DeltaPos -> Bool #
Data DeltaPos
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeltaPos -> c DeltaPos # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DeltaPos # toConstr :: DeltaPos -> Constr # dataTypeOf :: DeltaPos -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DeltaPos) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeltaPos) # gmapT :: (forall b. Data b => b -> b) -> DeltaPos -> DeltaPos # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r # gmapQ :: (forall d. Data d => d -> u) -> DeltaPos -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DeltaPos -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos #
Ord DeltaPos
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods compare :: DeltaPos -> DeltaPos -> Ordering # (<) :: DeltaPos -> DeltaPos -> Bool # (<=) :: DeltaPos -> DeltaPos -> Bool # (>) :: DeltaPos -> DeltaPos -> Bool # (>=) :: DeltaPos -> DeltaPos -> Bool # max :: DeltaPos -> DeltaPos -> DeltaPos # min :: DeltaPos -> DeltaPos -> DeltaPos #
Show DeltaPos
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods showsPrec :: Int -> DeltaPos -> ShowS # show :: DeltaPos -> String # showList :: [DeltaPos] -> ShowS #
Outputable DeltaPos
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods ppr :: DeltaPos -> SDoc # pprPrec :: Rational -> DeltaPos -> SDoc #

data AnnConName #

Constructors

CN
Fields unConName :: String

Instances

Eq AnnConName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods (==) :: AnnConName -> AnnConName -> Bool # (/=) :: AnnConName -> AnnConName -> Bool #
Data AnnConName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnConName -> c AnnConName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnConName # toConstr :: AnnConName -> Constr # dataTypeOf :: AnnConName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnConName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnConName) # gmapT :: (forall b. Data b => b -> b) -> AnnConName -> AnnConName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnConName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnConName -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnConName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnConName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnConName -> m AnnConName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnConName -> m AnnConName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnConName -> m AnnConName #
Ord AnnConName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods compare :: AnnConName -> AnnConName -> Ordering # (<) :: AnnConName -> AnnConName -> Bool # (<=) :: AnnConName -> AnnConName -> Bool # (>) :: AnnConName -> AnnConName -> Bool # (>=) :: AnnConName -> AnnConName -> Bool # max :: AnnConName -> AnnConName -> AnnConName # min :: AnnConName -> AnnConName -> AnnConName #
Show AnnConName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods showsPrec :: Int -> AnnConName -> ShowS # show :: AnnConName -> String # showList :: [AnnConName] -> ShowS #
Outputable AnnConName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods ppr :: AnnConName -> SDoc # pprPrec :: Rational -> AnnConName -> SDoc #

data KeywordId #

The different syntactic elements which are not represented in the AST.

Constructors

G AnnKeywordId	A normal keyword
AnnSemiSep	A separating comma
AnnTypeApp	Visible type application annotation
AnnComment Comment
AnnString String	Used to pass information from Delta to Print when we have to work out details from the original SrcSpan.

Instances

Eq KeywordId
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods (==) :: KeywordId -> KeywordId -> Bool # (/=) :: KeywordId -> KeywordId -> Bool #
Data KeywordId
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KeywordId -> c KeywordId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KeywordId # toConstr :: KeywordId -> Constr # dataTypeOf :: KeywordId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c KeywordId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeywordId) # gmapT :: (forall b. Data b => b -> b) -> KeywordId -> KeywordId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KeywordId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KeywordId -> r # gmapQ :: (forall d. Data d => d -> u) -> KeywordId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> KeywordId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> KeywordId -> m KeywordId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KeywordId -> m KeywordId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KeywordId -> m KeywordId #
Ord KeywordId
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods compare :: KeywordId -> KeywordId -> Ordering # (<) :: KeywordId -> KeywordId -> Bool # (<=) :: KeywordId -> KeywordId -> Bool # (>) :: KeywordId -> KeywordId -> Bool # (>=) :: KeywordId -> KeywordId -> Bool # max :: KeywordId -> KeywordId -> KeywordId # min :: KeywordId -> KeywordId -> KeywordId #
Show KeywordId
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods showsPrec :: Int -> KeywordId -> ShowS # show :: KeywordId -> String # showList :: [KeywordId] -> ShowS #
Outputable KeywordId
Instance details Defined in Language.Haskell.GHC.ExactPrint.Types Methods ppr :: KeywordId -> SDoc # pprPrec :: Rational -> KeywordId -> SDoc #

annLeadingCommentEntryDelta :: Annotation -> DeltaPos #

Return the DP of the first item that generates output, either a comment or the entry DP

showGhc :: Outputable a => a -> String #

Show a GHC.Outputable structure