Safe Haskell	None
Language	Haskell2010

FastTags.Tag

Contents

types
process
util

Synopsis

data TagVal = TagVal {
- tvName :: !Text
- tvType :: !Type
- tvParent :: !(Maybe Text)
}
data Type
- = Function
- | Type
- | Constructor
- | Class
- | Module
- | Operator
- | Pattern
- | Family
- | Define
data Tag
- = Tag !(Pos TagVal)
- | RepeatableTag !(Pos TagVal)
- | Warning !(Pos String)
data Pos a = Pos {
- posOf :: !SrcPos
- valOf :: !a
}
data SrcPos = SrcPos {
- posFile :: !FilePath
- posLine :: !Line
- posOffset :: !Offset
- posPrefix :: Text
- posSuffix :: Text
}
newtype UnstrippedTokens = UnstrippedTokens [Token]
processFile :: FilePath -> Bool -> IO ([Pos TagVal], [String])
qualify :: Bool -> Maybe Text -> Pos TagVal -> Pos TagVal
findSrcPrefix :: [Text] -> Pos a -> Maybe Text
process :: FilePath -> Bool -> ByteString -> ([Pos TagVal], [String])
tokenizeInput :: FilePath -> Bool -> LitMode Void -> ByteString -> Either Text [Token]
processTokens :: ProcessMode -> [Token] -> ([Pos TagVal], [String])
isHsFile :: FilePath -> Bool
defaultModes :: (ProcessMode, LitMode Void)
determineModes :: FilePath -> Maybe (ProcessMode, LitMode Void)
data ProcessMode
- = ProcessVanilla
- | ProcessAlexHappy
unstrippedTokensOf :: UnstrippedTokens -> [Token]
stripNewlines :: UnstrippedTokens -> [Token]
breakBlocks :: ProcessMode -> UnstrippedTokens -> [UnstrippedTokens]
whereBlock :: UnstrippedTokens -> [UnstrippedTokens]

types

data TagVal Source #

Constructors

TagVal
Fields tvName :: !Text tvType :: !Type tvParent :: !(Maybe Text) parent of this tag; parent can only be of type Class, Data or Family

Instances

Instances details

Eq TagVal Source #
Instance details Defined in FastTags.Tag Methods (==) :: TagVal -> TagVal -> Bool # (/=) :: TagVal -> TagVal -> Bool #
Ord TagVal Source #
Instance details Defined in FastTags.Tag Methods compare :: TagVal -> TagVal -> Ordering # (<) :: TagVal -> TagVal -> Bool # (<=) :: TagVal -> TagVal -> Bool # (>) :: TagVal -> TagVal -> Bool # (>=) :: TagVal -> TagVal -> Bool # max :: TagVal -> TagVal -> TagVal # min :: TagVal -> TagVal -> TagVal #
Show TagVal Source #
Instance details Defined in FastTags.Tag Methods showsPrec :: Int -> TagVal -> ShowS # show :: TagVal -> String # showList :: [TagVal] -> ShowS #
NFData TagVal Source #
Instance details Defined in FastTags.Tag Methods rnf :: TagVal -> () #

data Type Source #

The Ord instance is used to sort tags with the same name. Given multiple matches, vim will visit them in order, so this should be in the order of interest.

We rely that Type < Constructor. TODO how and where? For sorting tags?

Constructors

Function
Type
Constructor
Class
Module
Operator
Pattern
Family
Define	Preprocessor #define

Instances

Instances details

Eq Type Source #
Instance details Defined in FastTags.Tag Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Ord Type Source #
Instance details Defined in FastTags.Tag Methods compare :: Type -> Type -> Ordering # (<) :: Type -> Type -> Bool # (<=) :: Type -> Type -> Bool # (>) :: Type -> Type -> Bool # (>=) :: Type -> Type -> Bool # max :: Type -> Type -> Type # min :: Type -> Type -> Type #
Show Type Source #
Instance details Defined in FastTags.Tag Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
NFData Type Source #
Instance details Defined in FastTags.Tag Methods rnf :: Type -> () #

data Tag Source #

Constructors

Tag !(Pos TagVal)
RepeatableTag !(Pos TagVal)	Just like Tag, except these should be deduplicated by their TagVal, where the one with the lowest line number will be preferred. The idea seems to be that functions will emit a tag for both the signature and definition. TODO seems like a hack, why not just deduplicate all tags? And I think I do that now with dropAdjacent.
Warning !(Pos String)

Instances

Instances details

Eq Tag Source #
Instance details Defined in FastTags.Tag Methods (==) :: Tag -> Tag -> Bool # (/=) :: Tag -> Tag -> Bool #
Ord Tag Source #
Instance details Defined in FastTags.Tag Methods compare :: Tag -> Tag -> Ordering # (<) :: Tag -> Tag -> Bool # (<=) :: Tag -> Tag -> Bool # (>) :: Tag -> Tag -> Bool # (>=) :: Tag -> Tag -> Bool # max :: Tag -> Tag -> Tag # min :: Tag -> Tag -> Tag #
Show Tag Source #
Instance details Defined in FastTags.Tag Methods showsPrec :: Int -> Tag -> ShowS # show :: Tag -> String # showList :: [Tag] -> ShowS #

data Pos a Source #

Constructors

Pos
Fields posOf :: !SrcPos valOf :: !a

Instances

Instances details

Eq a => Eq (Pos a) Source #
Instance details Defined in FastTags.Token Methods (==) :: Pos a -> Pos a -> Bool # (/=) :: Pos a -> Pos a -> Bool #
Ord a => Ord (Pos a) Source #
Instance details Defined in FastTags.Token Methods compare :: Pos a -> Pos a -> Ordering # (<) :: Pos a -> Pos a -> Bool # (<=) :: Pos a -> Pos a -> Bool # (>) :: Pos a -> Pos a -> Bool # (>=) :: Pos a -> Pos a -> Bool # max :: Pos a -> Pos a -> Pos a # min :: Pos a -> Pos a -> Pos a #
Show a => Show (Pos a) Source #
Instance details Defined in FastTags.Token Methods showsPrec :: Int -> Pos a -> ShowS # show :: Pos a -> String # showList :: [Pos a] -> ShowS #
NFData a => NFData (Pos a) Source #
Instance details Defined in FastTags.Token Methods rnf :: Pos a -> () #

data SrcPos Source #

Constructors

SrcPos
Fields posFile :: !FilePath posLine :: !Line posOffset :: !Offset posPrefix :: Text No need to keep prefix strict since most of the prefixes will not be used. posSuffix :: Text

Instances

Instances details

Eq SrcPos Source #
Instance details Defined in FastTags.Token Methods (==) :: SrcPos -> SrcPos -> Bool # (/=) :: SrcPos -> SrcPos -> Bool #
Ord SrcPos Source #
Instance details Defined in FastTags.Token Methods compare :: SrcPos -> SrcPos -> Ordering # (<) :: SrcPos -> SrcPos -> Bool # (<=) :: SrcPos -> SrcPos -> Bool # (>) :: SrcPos -> SrcPos -> Bool # (>=) :: SrcPos -> SrcPos -> Bool # max :: SrcPos -> SrcPos -> SrcPos # min :: SrcPos -> SrcPos -> SrcPos #
Show SrcPos Source #
Instance details Defined in FastTags.Token Methods showsPrec :: Int -> SrcPos -> ShowS # show :: SrcPos -> String # showList :: [SrcPos] -> ShowS #
NFData SrcPos Source #
Instance details Defined in FastTags.Token Methods rnf :: SrcPos -> () #

newtype UnstrippedTokens Source #

Newlines have to remain in the tokens because breakBlocks relies on them. But they make pattern matching on the tokens unreliable because newlines might be anywhere. A newtype makes sure that the tokens only get stripped once and that I don't do any pattern matching on unstripped tokens.

Constructors

UnstrippedTokens [Token]

Instances

Instances details

Show UnstrippedTokens Source #
Instance details Defined in FastTags.Tag Methods showsPrec :: Int -> UnstrippedTokens -> ShowS # show :: UnstrippedTokens -> String # showList :: [UnstrippedTokens] -> ShowS #
Semigroup UnstrippedTokens Source #
Instance details Defined in FastTags.Tag Methods (<>) :: UnstrippedTokens -> UnstrippedTokens -> UnstrippedTokens # sconcat :: NonEmpty UnstrippedTokens -> UnstrippedTokens # stimes :: Integral b => b -> UnstrippedTokens -> UnstrippedTokens #
Monoid UnstrippedTokens Source #
Instance details Defined in FastTags.Tag Methods mempty :: UnstrippedTokens # mappend :: UnstrippedTokens -> UnstrippedTokens -> UnstrippedTokens # mconcat :: [UnstrippedTokens] -> UnstrippedTokens #

process

processFile :: FilePath -> Bool -> IO ([Pos TagVal], [String]) Source #

Read tags from one file.

qualify :: Bool -> Maybe Text -> Pos TagVal -> Pos TagVal Source #

Each tag is split into a one qualified with its module name and one without.

TODO I could mark it static, to put in a file: mark, which would make vim prioritize it for same-file tags, but I think it already does that, so maybe this isn't necessary?

findSrcPrefix :: [Text] -> Pos a -> Maybe Text Source #

process :: FilePath -> Bool -> ByteString -> ([Pos TagVal], [String]) Source #

Process one file's worth of tags.

tokenizeInput :: FilePath -> Bool -> LitMode Void -> ByteString -> Either Text [Token] Source #

processTokens :: ProcessMode -> [Token] -> ([Pos TagVal], [String]) Source #

util

isHsFile :: FilePath -> Bool Source #

Crude predicate for Haskell files

defaultModes :: (ProcessMode, LitMode Void) Source #

determineModes :: FilePath -> Maybe (ProcessMode, LitMode Void) Source #

data ProcessMode Source #

Constructors

ProcessVanilla	LitVanilla Haskell file - everything can produce tags
ProcessAlexHappy	Alex/Happy, only first and last braced blocks may produce tags

Instances

Instances details

Bounded ProcessMode Source #
Instance details Defined in FastTags.Tag Methods minBound :: ProcessMode # maxBound :: ProcessMode #
Enum ProcessMode Source #
Instance details Defined in FastTags.Tag Methods succ :: ProcessMode -> ProcessMode # pred :: ProcessMode -> ProcessMode # toEnum :: Int -> ProcessMode # fromEnum :: ProcessMode -> Int # enumFrom :: ProcessMode -> [ProcessMode] # enumFromThen :: ProcessMode -> ProcessMode -> [ProcessMode] # enumFromTo :: ProcessMode -> ProcessMode -> [ProcessMode] # enumFromThenTo :: ProcessMode -> ProcessMode -> ProcessMode -> [ProcessMode] #
Eq ProcessMode Source #
Instance details Defined in FastTags.Tag Methods (==) :: ProcessMode -> ProcessMode -> Bool # (/=) :: ProcessMode -> ProcessMode -> Bool #
Ord ProcessMode Source #
Instance details Defined in FastTags.Tag Methods compare :: ProcessMode -> ProcessMode -> Ordering # (<) :: ProcessMode -> ProcessMode -> Bool # (<=) :: ProcessMode -> ProcessMode -> Bool # (>) :: ProcessMode -> ProcessMode -> Bool # (>=) :: ProcessMode -> ProcessMode -> Bool # max :: ProcessMode -> ProcessMode -> ProcessMode # min :: ProcessMode -> ProcessMode -> ProcessMode #
Show ProcessMode Source #
Instance details Defined in FastTags.Tag Methods showsPrec :: Int -> ProcessMode -> ShowS # show :: ProcessMode -> String # showList :: [ProcessMode] -> ShowS #

unstrippedTokensOf :: UnstrippedTokens -> [Token] Source #

stripNewlines :: UnstrippedTokens -> [Token] Source #

It's easier to scan for tokens without pesky newlines popping up everywhere. But I need to keep the newlines in in case I hit a where and need to call breakBlocks again.

breakBlocks :: ProcessMode -> UnstrippedTokens -> [UnstrippedTokens] Source #

Break the input up into blocks based on indentation.

whereBlock :: UnstrippedTokens -> [UnstrippedTokens] Source #

Skip to the where and split the indented block below it.