Language.Haskell.Refact.Utils.LocUtils

Documentation

unmodified :: Bool

modified :: Bool

simpPos0 :: (Int, Int)

nullSrcSpan :: SrcSpan

whiteSpaceTokens :: (Int, Int) -> Int -> [PosToken]

realSrcLocFromTok :: PosToken -> RealSrcLoc

isWhite :: PosToken -> Bool

notWhite :: PosToken -> Bool

isWhiteSpace :: PosToken -> Bool

isWhiteSpaceOrIgnored :: IsToken a => a -> Bool

isIgnored :: IsToken a => a -> Bool

isMultiLineComment :: PosToken -> Bool

isOpenSquareBracket :: PosToken -> Bool

isCloseSquareBracket :: PosToken -> Bool

isIn :: IsToken a => a -> Bool

isComma :: PosToken -> Bool

isOpenParen :: PosToken -> Bool

isBar :: PosToken -> Bool

endsWithNewLn :: PosToken -> Bool

Returns True if the token ends with '\n' ++AZ++: is this meaningful?

startsWithNewLn :: PosToken -> Bool

Returns True if the token starts with `\n`. ++AZ++: is this meaningful?

hasNewLn :: PosToken -> Bool

compressPreNewLns :: [PosToken] -> [PosToken]

Remove the extra preceding empty lines.

compressEndNewLns :: [PosToken] -> [PosToken]

Remove the following extra empty lines.

lengthOfLastLine :: [PosToken] -> Int

Given a token stream covering multi-lines, calculate the length of the last line AZ: should be the last token start col, plus length of token.

getToks :: (SimpPos, SimpPos) -> [PosToken] -> [PosToken]

get a token stream specified by the start and end position.

deleteToks :: [PosToken] -> SimpPos -> SimpPos -> [PosToken]

Delete a sequence of tokens specified by the start position and end position from the token stream, then adjust the remaining token stream to preserve layout

doRmWhites :: Int -> [PosToken] -> [PosToken]

remove at most n white space tokens from the beginning of ts

srcLocs :: Data t => t -> [SimpPos]

get all the source locations (use locations) in an AST phrase t according the the occurrence order of identifiers.

getSrcSpan :: Data t => t -> Maybe SrcSpan

Get the first SrcSpan found, in top down traversal

getAllSrcLocs :: Data t => t -> [(SimpPos, SimpPos)]

Get all the source locations in a given syntax fragment

getBiggestStartEndLoc :: Data t => t -> (SimpPos, SimpPos)

extendForwards :: [PosToken] -> (SimpPos, SimpPos) -> (PosToken -> Bool) -> (SimpPos, SimpPos)

Extend the given position forwards to the end of the file while the supplied condition holds

extendBackwards :: [PosToken] -> (SimpPos, SimpPos) -> (PosToken -> Bool) -> (SimpPos, SimpPos)

Extend the given position backwards to the front of the file while the supplied condition holds

startEndLocIncFowComment :: Data t => [PosToken] -> t -> (SimpPos, SimpPos)

Get the start&end location of syntax phrase t, then extend the end location to cover the comment/white spaces or new line which starts in the same line as the end location TODO: deprecate this in favour of startEndLocIncComments

startEndLocIncComments :: Data t => [PosToken] -> t -> (SimpPos, SimpPos)

Get the start&end location of t in the token stream, then extend the start and end location to cover the preceding and following comments.

In this routine, 'then','else','do' and 'in' are treated as comments.

startEndLocIncComments' :: IsToken a => [a] -> (SimpPos, SimpPos) -> (SimpPos, SimpPos)

Get the start&end location of t in the token stream, then extend the start and end location to cover the preceding and following comments.

prettyprintPatList :: (t -> String) -> Bool -> [t] -> String

groupTokensByLine :: IsToken a => [a] -> [[a]]

toksOnSameLine :: PosToken -> PosToken -> Bool

addLocInfo :: (LHsBind Name, [PosToken]) -> RefactGhc (LHsBind Name, [PosToken])

getLineOffset :: [PosToken] -> SimpPos -> Int

Get the start of the line before the pos,

tokenSrcSpan :: (Located t1, t) -> SrcSpan

tokenCon :: PosToken -> String

increaseSrcSpan :: IsToken a => SimpPos -> a -> a

Shift the whole token by the given offset

getGhcLoc :: SrcSpan -> (Int, Int)

gets the (row,col) of the start of the GHC.SrcSpan, or (-1,-1) if there is an GHC.UnhelpfulSpan

getGhcLocEnd :: SrcSpan -> (Int, Int)

gets the (row,col) of the end of the GHC.SrcSpan, or (-1,-1) if there is an GHC.UnhelpfulSpan

getLocatedStart :: GenLocated SrcSpan t -> (Int, Int)

getLocatedEnd :: GenLocated SrcSpan t -> (Int, Int)

getStartEndLoc :: Data t => t -> (SimpPos, SimpPos)

startEndLocGhc :: Located b -> (SimpPos, SimpPos)

realSrcLocEndTok :: PosToken -> RealSrcLoc

fileNameFromTok :: PosToken -> FastString

splitToks :: IsToken a => (SimpPos, SimpPos) -> [a] -> ([a], [a], [a])

Split the token stream into three parts: the tokens before the startPos, the tokens between startPos and endPos, and the tokens after endPos. Note: The startPos and endPos refer to the startPos of a token only. So a single token will have the same startPos and endPos NO^^^^

emptyList :: [t] -> Bool

Get around lack of instance Eq when simply testing for empty list TODO: get rid of this in favour of null built in fn

nonEmptyList :: [t] -> Bool

notWhiteSpace :: IsToken a => a -> Bool

isDoubleColon :: PosToken -> Bool

isEmpty :: IsToken a => a -> Bool

Zero-length tokens, as appear in GHC as markers

isWhereOrLet :: IsToken a => a -> Bool

isWhere :: IsToken a => a -> Bool

isLet :: IsToken a => a -> Bool

isElse :: IsToken a => a -> Bool

isThen :: IsToken a => a -> Bool

isOf :: IsToken a => a -> Bool

isDo :: IsToken a => a -> Bool

getIndentOffset :: IsToken a => [a] -> SimpPos -> Int

Get the indent of the line before, taking into account in-line 'where', 'let', 'in' and 'do' tokens

splitOnNewLn :: IsToken a => [a] -> ([a], [a])

tokenLen :: IsToken a => a -> Int

tokenLen returns the length of the string representation of the token, not just the difference in the location, as the string may have changed without the position being updated, e.g. in a renaming

newLnToken :: IsToken a => a -> a

reSequenceToks :: [PosToken] -> [PosToken]

Adjust token stream to cater for changes in token length due to token renaming

mkToken :: Token -> SimpPos -> String -> GhcPosToken

Compose a new token using the given arguments.

mkZeroToken :: IsToken a => a

markToken :: IsToken a => a -> a

Mark a token so that it can be use to trigger layout checking later when the toks are retrieved

isMarked :: IsToken a => a -> Bool

rmOffsetFromToks :: [PosToken] -> [PosToken]