| Safe Haskell | Ignore |
|---|---|
| Language | GHC2021 |
GHC.Parser.Annotation
Contents
- Core Exact Print Annotation types
- In-tree Exact Print Annotations
- Comments in Annotations
- Annotations in
GenLocated - Annotation data types used in
GenLocated - Trailing annotations in lists
- Utilities for converting between different
GenLocatedwhen - we do not care about the annotations.
- Building up annotations
- Querying annotations
- Working with locations of annotations
- Constructing
GenLocatedannotation types when we do not care - Working with comments in annotations
Synopsis
- data EpToken (tok :: Symbol)
- = NoEpTok
- | EpTok !EpaLocation
- data EpUniToken (tok :: Symbol) (utok :: Symbol)
- getEpTokenSrcSpan :: forall (tok :: Symbol). EpToken tok -> SrcSpan
- getEpTokenBufSpan :: forall (tok :: Symbol). EpToken tok -> Maybe BufSpan
- getEpTokenLocs :: forall (tok :: Symbol). [EpToken tok] -> [EpaLocation]
- getEpTokenLoc :: forall (tok :: Symbol). EpToken tok -> EpaLocation
- getEpUniTokenLoc :: forall (tok :: Symbol) (toku :: Symbol). EpUniToken tok toku -> EpaLocation
- type TokDcolon = EpUniToken "::" "\8759"
- type TokDarrow = EpUniToken "=>" "\8658"
- type TokRarrow = EpUniToken "->" "\8594"
- type TokForall = EpUniToken "forall" "\8704"
- data EpLayout
- = EpExplicitBraces !(EpToken "{") !(EpToken "}")
- | EpVirtualBraces !Int
- | EpNoLayout
- data EpaComment = EpaComment {}
- data EpaCommentTok
- data IsUnicodeSyntax
- data HasE
- type EpaLocation = EpaLocation' [LEpaComment]
- data EpaLocation' a
- epaLocationRealSrcSpan :: EpaLocation' a -> RealSrcSpan
- data DeltaPos
- = SameLine {
- deltaColumn :: !Int
- | DifferentLine {
- deltaLine :: !Int
- deltaColumn :: !Int
- = SameLine {
- deltaPos :: Int -> Int -> DeltaPos
- getDeltaLine :: DeltaPos -> Int
- data EpAnn ann = EpAnn {
- entry :: !EpaLocation
- anns :: !ann
- comments :: !EpAnnComments
- spanAsAnchor :: SrcSpan -> EpaLocation' a
- realSpanAsAnchor :: RealSrcSpan -> EpaLocation' a
- noSpanAnchor :: NoAnn a => EpaLocation' a
- class NoAnn a where
- noAnn :: a
- data EpAnnComments
- = EpaComments {
- priorComments :: ![LEpaComment]
- | EpaCommentsBalanced {
- priorComments :: ![LEpaComment]
- followingComments :: ![LEpaComment]
- = EpaComments {
- type LEpaComment = GenLocated NoCommentsLocation EpaComment
- type NoCommentsLocation = EpaLocation' NoComments
- data NoComments = NoComments
- emptyComments :: EpAnnComments
- epaToNoCommentsLocation :: EpaLocation -> NoCommentsLocation
- noCommentsToEpaLocation :: NoCommentsLocation -> EpaLocation
- getFollowingComments :: EpAnnComments -> [LEpaComment]
- setFollowingComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
- setPriorComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments
- type EpAnnCO = EpAnn NoEpAnns
- type LocatedA = GenLocated SrcSpanAnnA
- type LocatedL = GenLocated SrcSpanAnnL
- type LocatedC = GenLocated SrcSpanAnnC
- type LocatedN = GenLocated SrcSpanAnnN
- type LocatedAn an = GenLocated (EpAnn an)
- type LocatedP = GenLocated SrcSpanAnnP
- type LocatedLC = GenLocated SrcSpanAnnLC
- type LocatedLS = GenLocated SrcSpanAnnLS
- type LocatedLW = GenLocated SrcSpanAnnLW
- type LocatedLI = GenLocated SrcSpanAnnLI
- type SrcSpanAnnA = EpAnn AnnListItem
- type SrcSpanAnnL = EpAnn (AnnList ())
- type SrcSpanAnnP = EpAnn AnnPragma
- type SrcSpanAnnC = EpAnn AnnContext
- type SrcSpanAnnN = EpAnn NameAnn
- type SrcSpanAnnLC = EpAnn (AnnList [EpToken ","])
- type SrcSpanAnnLW = EpAnn (AnnList (EpToken "where"))
- type SrcSpanAnnLS = EpAnn (AnnList ())
- type SrcSpanAnnLI = EpAnn (AnnList (EpToken "hiding", [EpToken ","]))
- type LocatedE = GenLocated EpaLocation
- data AnnListItem = AnnListItem {
- lann_trailing :: [TrailingAnn]
- data AnnList a = AnnList {
- al_anchor :: !(Maybe EpaLocation)
- al_brackets :: !AnnListBrackets
- al_semis :: [EpToken ";"]
- al_rest :: !a
- al_trailing :: ![TrailingAnn]
- data AnnListBrackets
- = ListParens (EpToken "(") (EpToken ")")
- | ListBraces (EpToken "{") (EpToken "}")
- | ListSquare (EpToken "[") (EpToken "]")
- | ListBanana (EpUniToken "(|" "\10631") (EpUniToken "|)" "\10632")
- | ListNone
- data AnnParen
- = AnnParens (EpToken "(") (EpToken ")")
- | AnnParensHash (EpToken "(#") (EpToken "#)")
- | AnnParensSquare (EpToken "[") (EpToken "]")
- data AnnPragma = AnnPragma {
- apr_open :: EpaLocation
- apr_close :: EpToken "#-}"
- apr_squares :: (EpToken "[", EpToken "]")
- apr_loc1 :: EpaLocation
- apr_loc2 :: EpaLocation
- apr_type :: EpToken "type"
- apr_module :: EpToken "module"
- data AnnContext = AnnContext {}
- data NameAnn
- = NameAnn { }
- | NameAnnCommas {
- nann_adornment :: NameAdornment
- nann_commas :: [EpToken ","]
- nann_trailing :: [TrailingAnn]
- | NameAnnBars {
- nann_parensh :: (EpToken "(#", EpToken "#)")
- nann_bars :: [EpToken "|"]
- nann_trailing :: [TrailingAnn]
- | NameAnnOnly { }
- | NameAnnRArrow {
- nann_mopen :: Maybe (EpToken "(")
- nann_arrow :: TokRarrow
- nann_mclose :: Maybe (EpToken ")")
- nann_trailing :: [TrailingAnn]
- | NameAnnQuote {
- nann_quote :: EpToken "'"
- nann_quoted :: SrcSpanAnnN
- nann_trailing :: [TrailingAnn]
- | NameAnnTrailing {
- nann_trailing :: [TrailingAnn]
- data NameAdornment
- = NameParens (EpToken "(") (EpToken ")")
- | NameParensHash (EpToken "(#") (EpToken "#)")
- | NameBackquotes (EpToken "`") (EpToken "`")
- | NameSquare (EpToken "[") (EpToken "]")
- | NameNoAdornment
- data NoEpAnns = NoEpAnns
- data AnnSortKey tag
- = NoAnnSortKey
- | AnnSortKey [tag]
- data DeclTag
- data BindTag
- data TrailingAnn
- = AddSemiAnn (EpToken ";")
- | AddCommaAnn (EpToken ",")
- | AddVbarAnn (EpToken "|")
- | AddDarrowAnn TokDarrow
- ta_location :: TrailingAnn -> EpaLocation
- addTrailingAnnToA :: TrailingAnn -> EpAnnComments -> EpAnn AnnListItem -> EpAnn AnnListItem
- addTrailingAnnToL :: TrailingAnn -> EpAnnComments -> EpAnn (AnnList a) -> EpAnn (AnnList a)
- addTrailingCommaToN :: EpAnn NameAnn -> EpaLocation -> EpAnn NameAnn
- noTrailingN :: SrcSpanAnnN -> SrcSpanAnnN
- l2l :: (HasLoc a, HasAnnotation b) => a -> b
- la2la :: (HasLoc l, HasAnnotation l2) => GenLocated l a -> GenLocated l2 a
- reLoc :: (HasLoc (GenLocated a e), HasAnnotation b) => GenLocated a e -> GenLocated b e
- class HasLoc a where
- getHasLocList :: HasLoc a => [a] -> SrcSpan
- srcSpan2e :: SrcSpan -> EpaLocation
- realSrcSpan :: SrcSpan -> RealSrcSpan
- addAnnsA :: SrcSpanAnnA -> [TrailingAnn] -> EpAnnComments -> SrcSpanAnnA
- widenSpanL :: SrcSpan -> [EpaLocation] -> SrcSpan
- widenSpanT :: forall (tok :: Symbol). SrcSpan -> EpToken tok -> SrcSpan
- widenAnchorT :: forall (tok :: Symbol). EpaLocation -> EpToken tok -> EpaLocation
- widenAnchorS :: EpaLocation -> SrcSpan -> EpaLocation
- widenLocatedAnL :: EpAnn an -> [EpaLocation] -> EpAnn an
- listLocation :: [LocatedAn an a] -> EpaLocation
- getLocAnn :: Located a -> SrcSpanAnnA
- epAnnComments :: EpAnn an -> EpAnnComments
- sortLocatedA :: HasLoc (EpAnn a) => [GenLocated (EpAnn a) e] -> [GenLocated (EpAnn a) e]
- mapLocA :: NoAnn ann => (a -> b) -> GenLocated SrcSpan a -> GenLocated (EpAnn ann) b
- combineLocsA :: Semigroup a => GenLocated (EpAnn a) e1 -> GenLocated (EpAnn a) e2 -> EpAnn a
- combineSrcSpansA :: Semigroup a => EpAnn a -> EpAnn a -> EpAnn a
- addCLocA :: (HasLoc a, HasLoc b, HasAnnotation l) => a -> b -> c -> GenLocated l c
- class HasAnnotation e where
- noAnnSrcSpan :: SrcSpan -> e
- locA :: HasLoc a => a -> SrcSpan
- noLocA :: HasAnnotation e => a -> GenLocated e a
- getLocA :: HasLoc a => GenLocated a e -> SrcSpan
- noSrcSpanA :: HasAnnotation e => e
- noComments :: EpAnnCO
- comment :: RealSrcSpan -> EpAnnComments -> EpAnnCO
- addCommentsToEpAnn :: NoAnn ann => EpAnn ann -> EpAnnComments -> EpAnn ann
- setCommentsEpAnn :: NoAnn ann => EpAnn ann -> EpAnnComments -> EpAnn ann
- transferAnnsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA)
- transferAnnsOnlyA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA)
- transferCommentsOnlyA :: EpAnn a -> EpAnn b -> (EpAnn a, EpAnn b)
- transferPriorCommentsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA)
- transferFollowingA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA)
- placeholderRealSpan :: RealSrcSpan
Core Exact Print Annotation types
data EpToken (tok :: Symbol) #
A token stored in the syntax tree. For example, when parsing a
let-expression, we store EpToken "let" and EpToken "in".
The locations of those tokens can be used to faithfully reproduce
(exactprint) the original program text.
Constructors
| NoEpTok | |
| EpTok !EpaLocation |
Instances
| KnownSymbol tok => Data (EpToken tok) # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpToken tok -> c (EpToken tok) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (EpToken tok) # toConstr :: EpToken tok -> Constr # dataTypeOf :: EpToken tok -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (EpToken tok)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (EpToken tok)) # gmapT :: (forall b. Data b => b -> b) -> EpToken tok -> EpToken tok # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpToken tok -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpToken tok -> r # gmapQ :: (forall d. Data d => d -> u) -> EpToken tok -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EpToken tok -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpToken tok -> m (EpToken tok) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpToken tok -> m (EpToken tok) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpToken tok -> m (EpToken tok) # | |
| HasLoc (EpToken tok) # | |
Defined in GHC.Parser.Annotation | |
| NoAnn (EpToken s) # | |
Defined in GHC.Parser.Annotation | |
| KnownSymbol tok => Outputable (EpToken tok) # | |
Defined in GHC.Parser.Annotation | |
| Eq (EpToken tok) # | |
data EpUniToken (tok :: Symbol) (utok :: Symbol) #
With UnicodeSyntax, there might be multiple ways to write the same
token. For example an arrow could be either -> or →. This choice must be
recorded in order to exactprint such tokens, so instead of EpToken "->" we
introduce EpUniToken "->" "→".
Constructors
| NoEpUniTok | |
| EpUniTok !EpaLocation !IsUnicodeSyntax |
Instances
| (KnownSymbol tok, KnownSymbol utok) => Data (EpUniToken tok utok) # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpUniToken tok utok -> c (EpUniToken tok utok) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (EpUniToken tok utok) # toConstr :: EpUniToken tok utok -> Constr # dataTypeOf :: EpUniToken tok utok -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (EpUniToken tok utok)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (EpUniToken tok utok)) # gmapT :: (forall b. Data b => b -> b) -> EpUniToken tok utok -> EpUniToken tok utok # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpUniToken tok utok -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpUniToken tok utok -> r # gmapQ :: (forall d. Data d => d -> u) -> EpUniToken tok utok -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EpUniToken tok utok -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpUniToken tok utok -> m (EpUniToken tok utok) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpUniToken tok utok -> m (EpUniToken tok utok) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpUniToken tok utok -> m (EpUniToken tok utok) # | |
| HasLoc (EpUniToken tok utok) # | |
Defined in GHC.Parser.Annotation Methods getHasLoc :: EpUniToken tok utok -> SrcSpan # | |
| NoAnn (EpUniToken s t) # | |
Defined in GHC.Parser.Annotation Methods noAnn :: EpUniToken s t # | |
| (KnownSymbol tok, KnownSymbol utok) => Outputable (EpUniToken tok utok) # | |
Defined in GHC.Parser.Annotation Methods ppr :: EpUniToken tok utok -> SDoc # | |
| Eq (EpUniToken tok utok) # | |
Defined in GHC.Parser.Annotation Methods (==) :: EpUniToken tok utok -> EpUniToken tok utok -> Bool # (/=) :: EpUniToken tok utok -> EpUniToken tok utok -> Bool # | |
getEpTokenSrcSpan :: forall (tok :: Symbol). EpToken tok -> SrcSpan #
getEpTokenLocs :: forall (tok :: Symbol). [EpToken tok] -> [EpaLocation] #
getEpTokenLoc :: forall (tok :: Symbol). EpToken tok -> EpaLocation #
getEpUniTokenLoc :: forall (tok :: Symbol) (toku :: Symbol). EpUniToken tok toku -> EpaLocation #
type TokDcolon = EpUniToken "::" "\8759" #
type TokDarrow = EpUniToken "=>" "\8658" #
type TokRarrow = EpUniToken "->" "\8594" #
type TokForall = EpUniToken "forall" "\8704" #
Layout information for declarations.
Constructors
| EpExplicitBraces !(EpToken "{") !(EpToken "}") | Explicit braces written by the user. class C a where { foo :: a; bar :: a }
|
| EpVirtualBraces | Virtual braces inserted by the layout algorithm. class C a where foo :: a bar :: a |
Fields
| |
| EpNoLayout | Empty or compiler-generated blocks do not have layout information associated with them. |
Instances
| Data EpLayout # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpLayout -> c EpLayout # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EpLayout # toConstr :: EpLayout -> Constr # dataTypeOf :: EpLayout -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EpLayout) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpLayout) # gmapT :: (forall b. Data b => b -> b) -> EpLayout -> EpLayout # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpLayout -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpLayout -> r # gmapQ :: (forall d. Data d => d -> u) -> EpLayout -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EpLayout -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpLayout -> m EpLayout # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpLayout -> m EpLayout # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpLayout -> m EpLayout # | |
data EpaComment #
Constructors
| EpaComment | |
Fields
| |
Instances
data EpaCommentTok #
Constructors
| EpaDocComment HsDocString | a docstring that can be pretty printed using pprHsDocString |
| EpaDocOptions String | doc options (prune, ignore-exports, etc) |
| EpaLineComment String | comment starting by "--" |
| EpaBlockComment String | comment in {- -} |
Instances
| Data EpaCommentTok # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpaCommentTok -> c EpaCommentTok # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EpaCommentTok # toConstr :: EpaCommentTok -> Constr # dataTypeOf :: EpaCommentTok -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EpaCommentTok) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpaCommentTok) # gmapT :: (forall b. Data b => b -> b) -> EpaCommentTok -> EpaCommentTok # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpaCommentTok -> r # gmapQ :: (forall d. Data d => d -> u) -> EpaCommentTok -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EpaCommentTok -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpaCommentTok -> m EpaCommentTok # | |
| Show EpaCommentTok # | |
Defined in GHC.Parser.Annotation Methods showsPrec :: Int -> EpaCommentTok -> ShowS # show :: EpaCommentTok -> String # showList :: [EpaCommentTok] -> ShowS # | |
| Eq EpaCommentTok # | |
Defined in GHC.Parser.Annotation Methods (==) :: EpaCommentTok -> EpaCommentTok -> Bool # (/=) :: EpaCommentTok -> EpaCommentTok -> Bool # | |
data IsUnicodeSyntax #
Certain tokens can have alternate representations when unicode syntax is
enabled. This flag is attached to those tokens in the lexer so that the
original source representation can be reproduced in the corresponding
EpAnnotation
Constructors
| UnicodeSyntax | |
| NormalSyntax |
Instances
Some template haskell tokens have two variants, one with an e the other
not:
[| or [e| [|| or [e||
This type indicates whether the e is present or not.
Instances
| Data HasE # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HasE -> c HasE # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HasE # dataTypeOf :: HasE -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HasE) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HasE) # gmapT :: (forall b. Data b => b -> b) -> HasE -> HasE # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HasE -> r # gmapQ :: (forall d. Data d => d -> u) -> HasE -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HasE -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HasE -> m HasE # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HasE -> m HasE # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HasE -> m HasE # | |
| Show HasE # | |
| Eq HasE # | |
| Ord HasE # | |
In-tree Exact Print Annotations
type EpaLocation = EpaLocation' [LEpaComment] #
data EpaLocation' a #
The anchor for an exact print annotation. The Parser inserts the
EpaSpanEpaDeltaSrcSpanmakeDeltaAst
Instances
epaLocationRealSrcSpan :: EpaLocation' a -> RealSrcSpan #
Used in the parser only, extract the RealSrcSpan from an
EpaLocation. The parser will never insert a DeltaPos, so the
partial function is safe.
Spacing between output items when exact printing. It captures
the spacing from the current print position on the page to the
position required for the thing about to be printed. This is
either on the same line in which case is is simply the number of
spaces to emit, or it is some number of lines down, with a given
column offset. The exact printing algorithm keeps track of the
column offset pertaining to the current anchor position, so the
deltaColumn is the additional spaces to add in this case. See
https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for
details.
Constructors
| SameLine | |
Fields
| |
| DifferentLine | |
Fields
| |
Instances
| Data DeltaPos # | |
Defined in GHC.Types.SrcLoc 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 :: forall r r'. (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 # | |
| Show DeltaPos # | |
| Outputable DeltaPos # | |
Defined in GHC.Types.SrcLoc | |
| Eq DeltaPos # | |
| Ord DeltaPos # | |
Defined in GHC.Types.SrcLoc | |
deltaPos :: Int -> Int -> DeltaPos #
Smart constructor for a DeltaPos. It preserves the invariant
that for the DifferentLine constructor deltaLine is always > 0.
getDeltaLine :: DeltaPos -> Int #
The exact print annotations (EPAs) are kept in the HsSyn AST for
the GhcPs phase. They are usually inserted into the AST by the parser,
and in case of generated code (e.g. by TemplateHaskell) they are usually
initialized using NoAnn type class.
A goal of the annotations is that an AST can be edited, including moving subtrees from one place to another, duplicating them, and so on. This means that each fragment must be self-contained. To this end, each annotated fragment keeps track of the anchor position it was originally captured at, being simply the start span of the topmost element of the ast fragment. This gives us a way to later re-calculate all Located items in this layer of the AST, as well as any annotations captured. The comments associated with the AST fragment are also captured here.
The ann type parameter allows this general structure to be
specialised to the specific set of locations of original exact
print annotation elements. For example
type SrcSpannAnnA = EpAnn AnnListItem
is a commonly used type alias that specializes the ann type parameter to
AnnListItem.
The spacing between the items under the scope of a given EpAnn is
normally derived from the original Anchor. But if a sub-element
is not in its original position, the required spacing can be
captured using an appropriate EpaDelta value for the entry Anchor.
This allows us to freely move elements around, and stitch together
new AST fragments out of old ones, and have them still printed out
in a precise way.
Constructors
| EpAnn | |
Fields
| |
Instances
spanAsAnchor :: SrcSpan -> EpaLocation' a #
realSpanAsAnchor :: RealSrcSpan -> EpaLocation' a #
noSpanAnchor :: NoAnn a => EpaLocation' a #
Instances
Comments in Annotations
data EpAnnComments #
When we are parsing we add comments that belong to a particular AST
element, and print them together with the element, interleaving
them into the output stream. But when editing the AST to move
fragments around it is useful to be able to first separate the
comments into those occurring before the AST element and those
following it. The EpaCommentsBalanced constructor is used to do
this. The GHC parser will only insert the EpaComments form.
Constructors
| EpaComments | |
Fields
| |
| EpaCommentsBalanced | |
Fields
| |
Instances
data NoComments #
Constructors
| NoComments |
Instances
setFollowingComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments #
setPriorComments :: EpAnnComments -> [LEpaComment] -> EpAnnComments #
Annotations in GenLocated
type LocatedA = GenLocated SrcSpanAnnA #
type LocatedL = GenLocated SrcSpanAnnL #
type LocatedC = GenLocated SrcSpanAnnC #
type LocatedN = GenLocated SrcSpanAnnN #
type LocatedAn an = GenLocated (EpAnn an) #
General representation of a GenLocated type carrying a
parameterised annotation type.
type LocatedP = GenLocated SrcSpanAnnP #
type LocatedLC = GenLocated SrcSpanAnnLC #
type LocatedLS = GenLocated SrcSpanAnnLS #
type LocatedLW = GenLocated SrcSpanAnnLW #
type LocatedLI = GenLocated SrcSpanAnnLI #
type SrcSpanAnnA = EpAnn AnnListItem #
type SrcSpanAnnL = EpAnn (AnnList ()) #
type SrcSpanAnnP = EpAnn AnnPragma #
type SrcSpanAnnC = EpAnn AnnContext #
type SrcSpanAnnN = EpAnn NameAnn #
type SrcSpanAnnLC = EpAnn (AnnList [EpToken ","]) #
type SrcSpanAnnLW = EpAnn (AnnList (EpToken "where")) #
type SrcSpanAnnLS = EpAnn (AnnList ()) #
type LocatedE = GenLocated EpaLocation #
Annotation data types used in GenLocated
data AnnListItem #
Annotation for items appearing in a list. They can have one or more trailing punctuations items, such as commas or semicolons.
Constructors
| AnnListItem | |
Fields
| |
Instances
Annotation for the "container" of a list. This captures surrounding items such as braces if present, and introductory keywords such as 'where'.
Constructors
| AnnList | |
Fields
| |
Instances
| Data a => Data (AnnList a) # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnList a -> c (AnnList a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnList a) # toConstr :: AnnList a -> Constr # dataTypeOf :: AnnList a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnList a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnList a)) # gmapT :: (forall b. Data b => b -> b) -> AnnList a -> AnnList a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnList a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnList a -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnList a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnList a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnList a -> m (AnnList a) # | |
| NoAnn a => NoAnn (AnnList a) # | |
Defined in GHC.Parser.Annotation | |
| Outputable a => Outputable (AnnList a) # | |
Defined in GHC.Parser.Annotation | |
| Eq a => Eq (AnnList a) # | |
data AnnListBrackets #
Constructors
| ListParens (EpToken "(") (EpToken ")") | |
| ListBraces (EpToken "{") (EpToken "}") | |
| ListSquare (EpToken "[") (EpToken "]") | |
| ListBanana (EpUniToken "(|" "\10631") (EpUniToken "|)" "\10632") | |
| ListNone |
Instances
| Data AnnListBrackets # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnListBrackets -> c AnnListBrackets # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnListBrackets # toConstr :: AnnListBrackets -> Constr # dataTypeOf :: AnnListBrackets -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnListBrackets) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnListBrackets) # gmapT :: (forall b. Data b => b -> b) -> AnnListBrackets -> AnnListBrackets # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnListBrackets -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnListBrackets -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnListBrackets -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnListBrackets -> m AnnListBrackets # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListBrackets -> m AnnListBrackets # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListBrackets -> m AnnListBrackets # | |
| Outputable AnnListBrackets # | |
Defined in GHC.Parser.Annotation Methods ppr :: AnnListBrackets -> SDoc # | |
| Eq AnnListBrackets # | |
Defined in GHC.Parser.Annotation Methods (==) :: AnnListBrackets -> AnnListBrackets -> Bool # (/=) :: AnnListBrackets -> AnnListBrackets -> Bool # | |
exact print annotation for an item having surrounding "brackets", such as tuples or lists
Constructors
| AnnParens (EpToken "(") (EpToken ")") | '(', ')' |
| AnnParensHash (EpToken "(#") (EpToken "#)") | '(#', '#)' |
| AnnParensSquare (EpToken "[") (EpToken "]") | '[', ']' |
Instances
| Data AnnParen # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnParen -> c AnnParen # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnParen # toConstr :: AnnParen -> Constr # dataTypeOf :: AnnParen -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnParen) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnParen) # gmapT :: (forall b. Data b => b -> b) -> AnnParen -> AnnParen # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnParen -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnParen -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnParen -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnParen -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnParen -> m AnnParen # | |
| NoAnn AnnParen # | |
Defined in GHC.Parser.Annotation | |
| Outputable AnnParen # | |
Defined in GHC.Parser.Annotation | |
exact print annotation used for capturing the locations of annotations in pragmas.
Constructors
| AnnPragma | |
Fields
| |
Instances
| Data AnnPragma # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnPragma -> c AnnPragma # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnPragma # toConstr :: AnnPragma -> Constr # dataTypeOf :: AnnPragma -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnPragma) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnPragma) # gmapT :: (forall b. Data b => b -> b) -> AnnPragma -> AnnPragma # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnPragma -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnPragma -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnPragma -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnPragma -> m AnnPragma # | |
| NoAnn AnnPragma # | |
Defined in GHC.Parser.Annotation | |
| Outputable AnnPragma # | |
Defined in GHC.Parser.Annotation | |
| Eq AnnPragma # | |
data AnnContext #
Exact print annotation for the Context data type.
Constructors
| AnnContext | |
Instances
| Data AnnContext # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnContext -> c AnnContext # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnContext # toConstr :: AnnContext -> Constr # dataTypeOf :: AnnContext -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnContext) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnContext) # gmapT :: (forall b. Data b => b -> b) -> AnnContext -> AnnContext # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnContext -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnContext -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnContext -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnContext -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnContext -> m AnnContext # | |
| NoAnn AnnContext # | |
Defined in GHC.Parser.Annotation Methods noAnn :: AnnContext # | |
| Outputable AnnContext # | |
Defined in GHC.Parser.Annotation Methods ppr :: AnnContext -> SDoc # | |
exact print annotations for a RdrName. There are many kinds of
adornment that can be attached to a given RdrName. This type
captures them, as detailed on the individual constructors.
Constructors
| NameAnn | Used for a name with an adornment, so |
Fields | |
| NameAnnCommas | |
Fields
| |
| NameAnnBars | Used for |
Fields
| |
| NameAnnOnly | Used for |
Fields | |
| NameAnnRArrow | Used for |
Fields
| |
| NameAnnQuote | Used for an item with a leading |
Fields
| |
| NameAnnTrailing | Used when adding a |
Fields
| |
Instances
| Data NameAnn # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameAnn -> c NameAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameAnn # toConstr :: NameAnn -> Constr # dataTypeOf :: NameAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAnn) # gmapT :: (forall b. Data b => b -> b) -> NameAnn -> NameAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameAnn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> NameAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn # | |
| NoAnn NameAnn # | |
Defined in GHC.Parser.Annotation | |
| Outputable NameAnn # | |
Defined in GHC.Parser.Annotation | |
| Eq NameAnn # | |
data NameAdornment #
A NameAnn can capture the locations of surrounding adornments,
such as parens or backquotes. This data type identifies what
particular pair are being used.
Constructors
| NameParens (EpToken "(") (EpToken ")") | |
| NameParensHash (EpToken "(#") (EpToken "#)") | |
| NameBackquotes (EpToken "`") (EpToken "`") | |
| NameSquare (EpToken "[") (EpToken "]") | |
| NameNoAdornment |
Instances
| Data NameAdornment # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameAdornment -> c NameAdornment # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameAdornment # toConstr :: NameAdornment -> Constr # dataTypeOf :: NameAdornment -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameAdornment) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAdornment) # gmapT :: (forall b. Data b => b -> b) -> NameAdornment -> NameAdornment # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameAdornment -> r # gmapQ :: (forall d. Data d => d -> u) -> NameAdornment -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameAdornment -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameAdornment -> m NameAdornment # | |
| Outputable NameAdornment # | |
Defined in GHC.Parser.Annotation Methods ppr :: NameAdornment -> SDoc # | |
| Eq NameAdornment # | |
Defined in GHC.Parser.Annotation Methods (==) :: NameAdornment -> NameAdornment -> Bool # (/=) :: NameAdornment -> NameAdornment -> Bool # | |
Constructors
| NoEpAnns |
Instances
| Data NoEpAnns # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoEpAnns -> c NoEpAnns # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoEpAnns # toConstr :: NoEpAnns -> Constr # dataTypeOf :: NoEpAnns -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NoEpAnns) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoEpAnns) # gmapT :: (forall b. Data b => b -> b) -> NoEpAnns -> NoEpAnns # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoEpAnns -> r # gmapQ :: (forall d. Data d => d -> u) -> NoEpAnns -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NoEpAnns -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoEpAnns -> m NoEpAnns # | |
| NoAnn NoEpAnns # | |
Defined in GHC.Parser.Annotation | |
| Outputable NoEpAnns # | |
Defined in GHC.Parser.Annotation | |
| Eq NoEpAnns # | |
| Ord NoEpAnns # | |
Defined in GHC.Parser.Annotation | |
data AnnSortKey tag #
Captures the sort order of sub elements for ValBinds,
ClassDecl, ClsInstDecl
Constructors
| NoAnnSortKey | |
| AnnSortKey [tag] |
Instances
| Monoid (AnnSortKey tag) # | |
Defined in GHC.Parser.Annotation Methods mempty :: AnnSortKey tag # mappend :: AnnSortKey tag -> AnnSortKey tag -> AnnSortKey tag # mconcat :: [AnnSortKey tag] -> AnnSortKey tag # | |
| Semigroup (AnnSortKey tag) # | |
Defined in GHC.Parser.Annotation Methods (<>) :: AnnSortKey tag -> AnnSortKey tag -> AnnSortKey tag # sconcat :: NonEmpty (AnnSortKey tag) -> AnnSortKey tag # stimes :: Integral b => b -> AnnSortKey tag -> AnnSortKey tag # | |
| Data tag => Data (AnnSortKey tag) # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnSortKey tag -> c (AnnSortKey tag) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnSortKey tag) # toConstr :: AnnSortKey tag -> Constr # dataTypeOf :: AnnSortKey tag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnSortKey tag)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnSortKey tag)) # gmapT :: (forall b. Data b => b -> b) -> AnnSortKey tag -> AnnSortKey tag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnSortKey tag -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnSortKey tag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnSortKey tag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnSortKey tag -> m (AnnSortKey tag) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnSortKey tag -> m (AnnSortKey tag) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnSortKey tag -> m (AnnSortKey tag) # | |
| Outputable tag => Outputable (AnnSortKey tag) # | |
Defined in GHC.Parser.Annotation Methods ppr :: AnnSortKey tag -> SDoc # | |
| Eq tag => Eq (AnnSortKey tag) # | |
Defined in GHC.Parser.Annotation Methods (==) :: AnnSortKey tag -> AnnSortKey tag -> Bool # (/=) :: AnnSortKey tag -> AnnSortKey tag -> Bool # | |
Used to track interleaving of class methods, class signatures,
associated types and associate type defaults in ClassDecl and
ClsInstDecl.
Constructors
| ClsMethodTag | |
| ClsSigTag | |
| ClsAtTag | |
| ClsAtdTag |
Instances
| Data DeclTag # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeclTag -> c DeclTag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DeclTag # toConstr :: DeclTag -> Constr # dataTypeOf :: DeclTag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DeclTag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeclTag) # gmapT :: (forall b. Data b => b -> b) -> DeclTag -> DeclTag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeclTag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeclTag -> r # gmapQ :: (forall d. Data d => d -> u) -> DeclTag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DeclTag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclTag -> m DeclTag # | |
| Show DeclTag # | |
| Outputable DeclTag # | |
Defined in GHC.Parser.Annotation | |
| Eq DeclTag # | |
| Ord DeclTag # | |
Defined in GHC.Parser.Annotation | |
Used to track of interleaving of binds and signatures for ValBind
Instances
| Data BindTag # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BindTag -> c BindTag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BindTag # toConstr :: BindTag -> Constr # dataTypeOf :: BindTag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BindTag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BindTag) # gmapT :: (forall b. Data b => b -> b) -> BindTag -> BindTag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BindTag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BindTag -> r # gmapQ :: (forall d. Data d => d -> u) -> BindTag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BindTag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BindTag -> m BindTag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BindTag -> m BindTag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BindTag -> m BindTag # | |
| Show BindTag # | |
| Outputable BindTag # | |
Defined in GHC.Parser.Annotation | |
| Eq BindTag # | |
| Ord BindTag # | |
Defined in GHC.Parser.Annotation | |
Trailing annotations in lists
data TrailingAnn #
Captures the location of punctuation occurring between items, normally in a list. It is captured as a trailing annotation.
Constructors
| AddSemiAnn (EpToken ";") | Trailing ';' |
| AddCommaAnn (EpToken ",") | Trailing ',' |
| AddVbarAnn (EpToken "|") | Trailing '|' |
| AddDarrowAnn TokDarrow | Trailing '=>' / |
Instances
| Data TrailingAnn # | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TrailingAnn -> c TrailingAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TrailingAnn # toConstr :: TrailingAnn -> Constr # dataTypeOf :: TrailingAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TrailingAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TrailingAnn) # gmapT :: (forall b. Data b => b -> b) -> TrailingAnn -> TrailingAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TrailingAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> TrailingAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TrailingAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TrailingAnn -> m TrailingAnn # | |
| Outputable TrailingAnn # | |
Defined in GHC.Parser.Annotation Methods ppr :: TrailingAnn -> SDoc # | |
| Eq TrailingAnn # | |
Defined in GHC.Parser.Annotation | |
ta_location :: TrailingAnn -> EpaLocation #
addTrailingAnnToA :: TrailingAnn -> EpAnnComments -> EpAnn AnnListItem -> EpAnn AnnListItem #
Helper function used in the parser to add a TrailingAnn items
to an existing annotation.
addTrailingAnnToL :: TrailingAnn -> EpAnnComments -> EpAnn (AnnList a) -> EpAnn (AnnList a) #
Helper function used in the parser to add a TrailingAnn items
to an existing annotation.
addTrailingCommaToN :: EpAnn NameAnn -> EpaLocation -> EpAnn NameAnn #
Helper function used in the parser to add a comma location to an existing annotation.
noTrailingN :: SrcSpanAnnN -> SrcSpanAnnN #
Utilities for converting between different GenLocated when
we do not care about the annotations.
l2l :: (HasLoc a, HasAnnotation b) => a -> b #
Helper function for converting annotation types. Discards any annotations
la2la :: (HasLoc l, HasAnnotation l2) => GenLocated l a -> GenLocated l2 a #
Helper function for converting annotation types. Discards any annotations
reLoc :: (HasLoc (GenLocated a e), HasAnnotation b) => GenLocated a e -> GenLocated b e #
Methods
conveniently calculate locations for things without locations attached
Instances
| HasLoc EpAnnLevel # | |
Defined in GHC.Hs.ImpExp Methods getHasLoc :: EpAnnLevel -> SrcSpan # | |
| HasLoc EpaLocation # | |
Defined in GHC.Parser.Annotation Methods getHasLoc :: EpaLocation -> SrcSpan # | |
| HasLoc SrcSpan # | |
Defined in GHC.Parser.Annotation | |
| HasLoc (EpAnn a) # | |
Defined in GHC.Parser.Annotation | |
| HasLoc (EpToken tok) # | |
Defined in GHC.Parser.Annotation | |
| HasLoc a => HasLoc (Maybe a) # | |
Defined in GHC.Parser.Annotation | |
| HasLoc (EpUniToken tok utok) # | |
Defined in GHC.Parser.Annotation Methods getHasLoc :: EpUniToken tok utok -> SrcSpan # | |
| HasLoc l => HasLoc (GenLocated l a) # | |
Defined in GHC.Parser.Annotation Methods getHasLoc :: GenLocated l a -> SrcSpan # | |
getHasLocList :: HasLoc a => [a] -> SrcSpan #
srcSpan2e :: SrcSpan -> EpaLocation #
realSrcSpan :: SrcSpan -> RealSrcSpan #
Building up annotations
addAnnsA :: SrcSpanAnnA -> [TrailingAnn] -> EpAnnComments -> SrcSpanAnnA #
widenSpanL :: SrcSpan -> [EpaLocation] -> SrcSpan #
The annotations need to all come after the anchor. Make sure this is the case.
widenAnchorT :: forall (tok :: Symbol). EpaLocation -> EpToken tok -> EpaLocation #
widenAnchorS :: EpaLocation -> SrcSpan -> EpaLocation #
widenLocatedAnL :: EpAnn an -> [EpaLocation] -> EpAnn an #
listLocation :: [LocatedAn an a] -> EpaLocation #
Querying annotations
getLocAnn :: Located a -> SrcSpanAnnA #
epAnnComments :: EpAnn an -> EpAnnComments #
Working with locations of annotations
sortLocatedA :: HasLoc (EpAnn a) => [GenLocated (EpAnn a) e] -> [GenLocated (EpAnn a) e] #
mapLocA :: NoAnn ann => (a -> b) -> GenLocated SrcSpan a -> GenLocated (EpAnn ann) b #
combineLocsA :: Semigroup a => GenLocated (EpAnn a) e1 -> GenLocated (EpAnn a) e2 -> EpAnn a #
addCLocA :: (HasLoc a, HasLoc b, HasAnnotation l) => a -> b -> c -> GenLocated l c #
Combine locations from two Located things and add them to a third thing
Constructing GenLocated annotation types when we do not care
class HasAnnotation e where #
Methods
noAnnSrcSpan :: SrcSpan -> e #
Instances
| HasAnnotation EpaLocation # | |
Defined in GHC.Parser.Annotation Methods noAnnSrcSpan :: SrcSpan -> EpaLocation # | |
| HasAnnotation SrcSpan # | |
Defined in GHC.Parser.Annotation Methods noAnnSrcSpan :: SrcSpan -> SrcSpan # | |
| NoAnn ann => HasAnnotation (EpAnn ann) # | |
Defined in GHC.Parser.Annotation Methods noAnnSrcSpan :: SrcSpan -> EpAnn ann # | |
noLocA :: HasAnnotation e => a -> GenLocated e a #
getLocA :: HasLoc a => GenLocated a e -> SrcSpan #
noSrcSpanA :: HasAnnotation e => e #
Working with comments in annotations
noComments :: EpAnnCO #
comment :: RealSrcSpan -> EpAnnComments -> EpAnnCO #
addCommentsToEpAnn :: NoAnn ann => EpAnn ann -> EpAnnComments -> EpAnn ann #
Add additional comments to a EpAnn, used for manipulating the
AST prior to exact printing the changed one.
setCommentsEpAnn :: NoAnn ann => EpAnn ann -> EpAnnComments -> EpAnn ann #
Replace any existing comments on a EpAnn, used for manipulating the
AST prior to exact printing the changed one.
transferAnnsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA) #
Transfer comments and trailing items from the annotations in the
first SrcSpanAnnA argument to those in the second.
transferAnnsOnlyA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA) #
Transfer trailing items from the annotations in the
first SrcSpanAnnA argument to those in the second.
transferCommentsOnlyA :: EpAnn a -> EpAnn b -> (EpAnn a, EpAnn b) #
Transfer comments from the annotations in the
first SrcSpanAnnA argument to those in the second.
transferPriorCommentsA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA) #
Transfer prior comments only from the annotations in the
first SrcSpanAnnA argument to those in the second.
transferFollowingA :: SrcSpanAnnA -> SrcSpanAnnA -> (SrcSpanAnnA, SrcSpanAnnA) #
Transfer trailing items but not comments from the annotations in the
first SrcSpanAnnA argument to those in the second.