| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Language.Haskell.HLint2
Description
WARNING: This module represents the evolving second version of the HLint API. It will be deleted in favour of Language.Haskell.HLint3 in the next major version.
This module provides a way to apply HLint hints. As an example of approximating the hlint experience:
(flags, classify, hint) <-autoSettingsRight m <-parseModuleExflags "MyFile.hs" Nothing print $applyHintsclassify hint [m]
- applyHints :: [Classify] -> Hint -> [(Module_, [Comment])] -> [Idea]
- data Idea = Idea {
- ideaModule :: String
- ideaDecl :: String
- ideaSeverity :: Severity
- ideaHint :: String
- ideaSpan :: SrcSpan
- ideaFrom :: String
- ideaTo :: Maybe String
- ideaNote :: [Note]
- ideaRefactoring :: [Refactoring SrcSpan]
- data Severity
- = Ignore
- | Suggestion
- | Warning
- | Error
- data Note
- data Classify = Classify {}
- getHLintDataDir :: IO FilePath
- autoSettings :: IO (ParseFlags, [Classify], Hint)
- autoSettings' :: FilePath -> IO (ParseFlags, [Classify], Hint)
- findSettings :: FilePath -> FilePath -> Maybe String -> IO ([String], [Module_])
- readSettings :: Module_ -> ([Classify], [HintRule])
- data Hint = Hint {
- hintModules :: [(Scope, Module_)] -> [Idea]
- hintModule :: Scope -> Module_ -> [Idea]
- hintDecl :: Scope -> Module_ -> Decl_ -> [Idea]
- hintComment :: Comment -> [Idea]
- builtinHints :: [(String, Hint)]
- data HintRule = HintRule {
- hintRuleSeverity :: Severity
- hintRuleName :: String
- hintRuleScope :: Scope
- hintRuleLHS :: Exp_
- hintRuleRHS :: Exp_
- hintRuleSide :: Maybe Exp_
- hintRuleNotes :: [Note]
- hintRules :: [HintRule] -> Hint
- data Scope
- scopeCreate :: Module_ -> Scope
- scopeMatch :: (Scope, QName S) -> (Scope, QName S) -> Bool
- scopeMove :: (Scope, QName S) -> Scope -> QName S
- parseModuleEx :: ParseFlags -> FilePath -> Maybe String -> IO (Either ParseError (Module_, [Comment]))
- defaultParseFlags :: ParseFlags
- data ParseError = ParseError {}
- data ParseFlags = ParseFlags {}
- data CppFlags
- type Encoding = TextEncoding
- defaultEncoding :: Encoding
- readEncoding :: String -> IO Encoding
- useEncoding :: Handle -> Encoding -> IO ()
Documentation
applyHints :: [Classify] -> Hint -> [(Module_, [Comment])] -> [Idea] #
Given a way of classifying results, and a Hint, apply to a set of modules generating a list of Ideas.
The Idea values will be ordered within a file.
Given a set of modules, it may be faster pass each to applyHints in a singleton list.
When given multiple modules at once this function attempts to find hints between modules,
which is slower and often pointless (by default HLint passes modules singularly, using
--cross to pass all modules together).
Idea data type
An idea suggest by a Hint.
Constructors
| Idea | |
Fields
| |
How severe an issue is.
Constructors
| Ignore | The issue has been explicitly ignored and will usually be hidden (pass |
| Suggestion | Suggestions are things that some people may consider improvements, but some may not. |
| Warning | Warnings are suggestions that are nearly always a good idea to apply. |
| Error | Available as a setting for the user. |
A note describing the impact of the replacement.
Constructors
| IncreasesLaziness | The replacement is increases laziness, for example replacing |
| DecreasesLaziness | The replacement is decreases laziness, for example replacing |
| RemovesError String | The replacement removes errors, for example replacing |
| ValidInstance String String | The replacement assumes standard type class lemmas, a hint with the note |
| Note String | An arbitrary note. |
Settings
How to classify an Idea. If any matching field is "" then it matches everything.
Constructors
| Classify | |
Fields
| |
getHLintDataDir :: IO FilePath #
Get the Cabal configured data directory of HLint
autoSettings :: IO (ParseFlags, [Classify], Hint) #
The function produces a tuple containg ParseFlags (for parseModuleEx), and Classify and Hint for applyHints.
It approximates the normal HLint configuration steps, roughly:
- Use
findSettingsto find and load the HLint settings files. - Use
readSettingsto interpret the settings files, producingHintRulevalues (LHS ==> RHSreplacements) andClassifyvalues to assignSeverityratings to hints. - Use
builtinHintsandhintRulesto generate aHintvalue. - Take all fixities from the
findSettingsmodules and put them in theParseFlags.
autoSettings' :: FilePath -> IO (ParseFlags, [Classify], Hint) #
Like autoSettings but with a custom data directory.
findSettings :: FilePath -> FilePath -> Maybe String -> IO ([String], [Module_]) #
Given the data directory (where the hlint data files reside, see getHLintDataDir),
and a filename to read, and optionally that file's contents, produce a pair containing:
- Builtin hints to use, e.g.
List, which should be resolved usingbuiltinHints. - A list of modules containing hints, suitable for processing with
readSettings.
Any parse failures will result in an exception.
readSettings :: Module_ -> ([Classify], [HintRule]) #
Hints
Functions to generate hints, combined using the Monoid instance.
Constructors
| Hint | |
Fields
| |
builtinHints :: [(String, Hint)] #
A list of builtin hints, currently including entries such as "List" and "Bracket".
A LHS ==> RHS style hint rule.
Constructors
| HintRule | |
Fields
| |
Scopes
Data type representing the modules in scope within a module.
Created with scopeCreate and queried with scopeMatch and scopeMove.
Note that the mempty Scope is not equivalent to scopeCreate on an empty module,
due to the implicit import of Prelude.
scopeCreate :: Module_ -> Scope #
Create a Scope value from a module, based on the modules imports.
scopeMatch :: (Scope, QName S) -> (Scope, QName S) -> Bool #
Given a two names in scopes, could they possibly refer to the same thing. This property is reflexive.
scopeMove :: (Scope, QName S) -> Scope -> QName S #
Given a name in a scope, and a new scope, create a name for the new scope that will refer to the same thing. If the resulting name is ambiguous, it picks a plausible candidate.
Haskell-src-exts
parseModuleEx :: ParseFlags -> FilePath -> Maybe String -> IO (Either ParseError (Module_, [Comment])) #
Parse a Haskell module. Applies the C pre processor, and uses best-guess fixity resolution if there are ambiguities.
The filename - is treated as stdin. Requires some flags (often defaultParseFlags), the filename, and optionally the contents of that file.
defaultParseFlags :: ParseFlags #
Default value for ParseFlags.
data ParseError #
A parse error from parseModuleEx.
Constructors
| ParseError | |
Fields
| |
What C pre processor should be used.
Constructors
| NoCpp | No pre processing is done. |
| CppSimple | Lines prefixed with |
| Cpphs CpphsOptions | The |
File encodings
type Encoding = TextEncoding #
An Encoding represents how characters are stored in a file. Created with
defaultEncoding or readEncoding and used with useEncoding.
The system default encoding.
readEncoding :: String -> IO Encoding #
Create an encoding from a string, or throw an error if the encoding is not known.
Accepts many encodings including locale, utf-8 and all those supported by the
GHC mkTextEncoding function.