Language.Haskell.Refact.Utils.LocUtils

Documentation

type SimpPos = (Int, Int)

unmodified :: Bool

modified :: Bool

simpPos0 :: (Int, Int)

nullSrcSpan :: SrcSpan

showToks :: [PosToken] -> String

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

realSrcLocFromTok :: PosToken -> RealSrcLoc

isWhite :: PosToken -> Bool

notWhite :: PosToken -> Bool

isWhiteSpace :: PosToken -> Bool

isWhiteSpaceOrIgnored :: PosToken -> Bool

isIgnored :: PosToken -> Bool

isIgnoredNonComment :: PosToken -> Bool

Tokens that are ignored when determining the first non-comment token in a span

isComment :: PosToken -> Bool

isMultiLineComment :: PosToken -> Bool

isOpenSquareBracket :: PosToken -> Bool

isCloseSquareBracket :: PosToken -> Bool

isIn :: PosToken -> Bool

isComma :: 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.

replaceTokNoReAlign :: [PosToken] -> SimpPos -> PosToken -> [PosToken]

Replace a single token in the token stream by a new token, without adjusting the layout. Note1: does not re-align, else other later replacements may fail. Note2: must keep original end col, to know what the inter-token gap was when re-aligning

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' :: [PosToken] -> (SimpPos, SimpPos) -> (SimpPos, SimpPos)

tokenise :: RealSrcLoc -> Int -> Bool -> String -> IO [PosToken]

Convert a string into a set of Haskell tokens, following the given position, with each line indented by a given column offset if required TODO: replace 'colOffset withFirstLineIndent' with a Maybe Int ++AZ++

basicTokenise :: String -> IO [PosToken]

Convert a string into a set of Haskell tokens. It has default position and offset, since it will be stitched into place in TokenUtils

lexStringToRichTokens :: RealSrcLoc -> String -> IO [PosToken]

prettyprint :: Outputable a => a -> String

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

groupTokensByLine :: [PosToken] -> [[PosToken]]

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,

tokenCol :: PosToken -> Int

tokenColEnd :: PosToken -> Int

tokenRow :: PosToken -> Int

tokenPos :: (GenLocated SrcSpan t1, t) -> SimpPos

tokenPosEnd :: (GenLocated SrcSpan t1, t) -> SimpPos

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

tokenCon :: PosToken -> String

increaseSrcSpan :: SimpPos -> PosToken -> PosToken

getGhcLoc :: SrcSpan -> (Int, Int)

getGhcLocEnd :: SrcSpan -> (Int, Int)

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 :: (SimpPos, SimpPos) -> [PosToken] -> ([PosToken], [PosToken], [PosToken])

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

nonEmptyList :: [t] -> Bool

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

Split a set of comment tokens into the ones that belong with the startLine and those that belong with the endLine

notWhiteSpace :: PosToken -> Bool

isDoubleColon :: PosToken -> Bool

isEmpty :: PosToken -> Bool

isWhereOrLet :: PosToken -> Bool

isWhere :: PosToken -> Bool

isLet :: PosToken -> Bool

isElse :: PosToken -> Bool

isThen :: PosToken -> Bool

isOf :: PosToken -> Bool

isDo :: PosToken -> Bool

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

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

splitOnNewLn :: [PosToken] -> ([PosToken], [PosToken])

tokenLen :: PosToken -> Int

newLnToken :: PosToken -> PosToken

newLinesToken :: Int -> PosToken -> PosToken

monotonicLineToks :: [PosToken] -> [PosToken]

sort out line numbering so that they are always monotonically increasing.

reSequenceToks :: [PosToken] -> [PosToken]

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

mkToken :: Token -> SimpPos -> String -> PosToken

Compose a new token using the given arguments.

mkZeroToken :: PosToken

markToken :: PosToken -> PosToken

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

isMarked :: PosToken -> Bool

Does a token have the file mark in it

addOffsetToToks :: SimpPos -> [PosToken] -> [PosToken]

Add a constant line and column offset to a span of tokens

matchTokenPos :: PosToken -> PosToken -> PosToken

Transfer the location information from the first param to the second