packages feed

hlint 2.1.26 → 2.2

raw patch · 3 files changed

+6/−122 lines, 3 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Language.Haskell.HLint3: Classify :: Severity -> String -> String -> String -> Classify
- Language.Haskell.HLint3: CppSimple :: CppFlags
- Language.Haskell.HLint3: Cpphs :: CpphsOptions -> CppFlags
- Language.Haskell.HLint3: DecreasesLaziness :: Note
- Language.Haskell.HLint3: Error :: Severity
- Language.Haskell.HLint3: Hint :: ([Setting] -> [(Scope, Module SrcSpanInfo)] -> [Idea]) -> ([Setting] -> Scope -> Module SrcSpanInfo -> [Idea]) -> ([Setting] -> Scope -> Module SrcSpanInfo -> Decl SrcSpanInfo -> [Idea]) -> ([Setting] -> Comment -> [Idea]) -> Hint
- Language.Haskell.HLint3: HintBracket :: HintBuiltin
- Language.Haskell.HLint3: HintComment :: HintBuiltin
- Language.Haskell.HLint3: HintDuplicate :: HintBuiltin
- Language.Haskell.HLint3: HintExport :: HintBuiltin
- Language.Haskell.HLint3: HintExtensions :: HintBuiltin
- Language.Haskell.HLint3: HintImport :: HintBuiltin
- Language.Haskell.HLint3: HintLambda :: HintBuiltin
- Language.Haskell.HLint3: HintList :: HintBuiltin
- Language.Haskell.HLint3: HintListRec :: HintBuiltin
- Language.Haskell.HLint3: HintMonad :: HintBuiltin
- Language.Haskell.HLint3: HintNaming :: HintBuiltin
- Language.Haskell.HLint3: HintNewType :: HintBuiltin
- Language.Haskell.HLint3: HintPattern :: HintBuiltin
- Language.Haskell.HLint3: HintPragma :: HintBuiltin
- Language.Haskell.HLint3: HintRestrict :: HintBuiltin
- Language.Haskell.HLint3: HintRule :: Severity -> String -> Scope -> Exp SrcSpanInfo -> Exp SrcSpanInfo -> Maybe (Exp SrcSpanInfo) -> [Note] -> HintRule
- Language.Haskell.HLint3: HintSmell :: HintBuiltin
- Language.Haskell.HLint3: HintUnsafe :: HintBuiltin
- Language.Haskell.HLint3: Idea :: [String] -> [String] -> Severity -> String -> SrcSpan -> String -> Maybe String -> [Note] -> [Refactoring SrcSpan] -> Idea
- Language.Haskell.HLint3: Ignore :: Severity
- Language.Haskell.HLint3: IncreasesLaziness :: Note
- Language.Haskell.HLint3: NoCpp :: CppFlags
- Language.Haskell.HLint3: Note :: String -> Note
- Language.Haskell.HLint3: ParseError :: SrcLoc -> String -> String -> ParseError
- Language.Haskell.HLint3: ParseFlags :: CppFlags -> ParseMode -> ParseFlags
- Language.Haskell.HLint3: RemovesError :: String -> Note
- Language.Haskell.HLint3: RequiresExtension :: String -> Note
- Language.Haskell.HLint3: Suggestion :: Severity
- Language.Haskell.HLint3: ValidInstance :: String -> String -> Note
- Language.Haskell.HLint3: Warning :: Severity
- Language.Haskell.HLint3: [classifyDecl] :: Classify -> String
- Language.Haskell.HLint3: [classifyHint] :: Classify -> String
- Language.Haskell.HLint3: [classifyModule] :: Classify -> String
- Language.Haskell.HLint3: [classifySeverity] :: Classify -> Severity
- Language.Haskell.HLint3: [cppFlags] :: ParseFlags -> CppFlags
- Language.Haskell.HLint3: [hintComment] :: Hint -> [Setting] -> Comment -> [Idea]
- Language.Haskell.HLint3: [hintDecl] :: Hint -> [Setting] -> Scope -> Module SrcSpanInfo -> Decl SrcSpanInfo -> [Idea]
- Language.Haskell.HLint3: [hintModule] :: Hint -> [Setting] -> Scope -> Module SrcSpanInfo -> [Idea]
- Language.Haskell.HLint3: [hintModules] :: Hint -> [Setting] -> [(Scope, Module SrcSpanInfo)] -> [Idea]
- Language.Haskell.HLint3: [hintRuleLHS] :: HintRule -> Exp SrcSpanInfo
- Language.Haskell.HLint3: [hintRuleName] :: HintRule -> String
- Language.Haskell.HLint3: [hintRuleNotes] :: HintRule -> [Note]
- Language.Haskell.HLint3: [hintRuleRHS] :: HintRule -> Exp SrcSpanInfo
- Language.Haskell.HLint3: [hintRuleScope] :: HintRule -> Scope
- Language.Haskell.HLint3: [hintRuleSeverity] :: HintRule -> Severity
- Language.Haskell.HLint3: [hintRuleSide] :: HintRule -> Maybe (Exp SrcSpanInfo)
- Language.Haskell.HLint3: [hseFlags] :: ParseFlags -> ParseMode
- Language.Haskell.HLint3: [ideaDecl] :: Idea -> [String]
- Language.Haskell.HLint3: [ideaFrom] :: Idea -> String
- Language.Haskell.HLint3: [ideaHint] :: Idea -> String
- Language.Haskell.HLint3: [ideaModule] :: Idea -> [String]
- Language.Haskell.HLint3: [ideaNote] :: Idea -> [Note]
- Language.Haskell.HLint3: [ideaRefactoring] :: Idea -> [Refactoring SrcSpan]
- Language.Haskell.HLint3: [ideaSeverity] :: Idea -> Severity
- Language.Haskell.HLint3: [ideaSpan] :: Idea -> SrcSpan
- Language.Haskell.HLint3: [ideaTo] :: Idea -> Maybe String
- Language.Haskell.HLint3: [parseErrorContents] :: ParseError -> String
- Language.Haskell.HLint3: [parseErrorLocation] :: ParseError -> SrcLoc
- Language.Haskell.HLint3: [parseErrorMessage] :: ParseError -> String
- Language.Haskell.HLint3: applyHints :: [Classify] -> Hint -> [(Module SrcSpanInfo, [Comment])] -> [Idea]
- Language.Haskell.HLint3: argsSettings :: [String] -> IO (ParseFlags, [Classify], Hint)
- Language.Haskell.HLint3: autoSettings :: IO (ParseFlags, [Classify], Hint)
- Language.Haskell.HLint3: data Classify
- Language.Haskell.HLint3: data CppFlags
- Language.Haskell.HLint3: data Hint
- Language.Haskell.HLint3: data HintBuiltin
- Language.Haskell.HLint3: data HintRule
- Language.Haskell.HLint3: data Idea
- Language.Haskell.HLint3: data Note
- Language.Haskell.HLint3: data ParseError
- Language.Haskell.HLint3: data ParseFlags
- Language.Haskell.HLint3: data Scope
- Language.Haskell.HLint3: data Severity
- Language.Haskell.HLint3: defaultParseFlags :: ParseFlags
- Language.Haskell.HLint3: findSettings :: (String -> IO (FilePath, Maybe String)) -> Maybe String -> IO ([Fixity], [Classify], [Either HintBuiltin HintRule])
- Language.Haskell.HLint3: getHLintDataDir :: IO FilePath
- Language.Haskell.HLint3: hlint :: [String] -> IO [Idea]
- Language.Haskell.HLint3: parseFlagsAddFixities :: [Fixity] -> ParseFlags -> ParseFlags
- Language.Haskell.HLint3: parseModuleEx :: ParseFlags -> FilePath -> Maybe String -> IO (Either ParseError (Module SrcSpanInfo, [Comment]))
- Language.Haskell.HLint3: readSettingsFile :: Maybe FilePath -> String -> IO (FilePath, Maybe String)
- Language.Haskell.HLint3: resolveHints :: [Either HintBuiltin HintRule] -> Hint
- Language.Haskell.HLint3: scopeCreate :: Module SrcSpanInfo -> Scope
- Language.Haskell.HLint3: scopeMatch :: (Scope, QName S) -> (Scope, QName S) -> Bool
- Language.Haskell.HLint3: scopeMove :: (Scope, QName S) -> Scope -> QName S

Files

CHANGES.txt view
@@ -1,5 +1,7 @@ Changelog for HLint (* = breaking change) +2.2, released 2019-06-26+*   Remove functions and make some things abstract in HLint3 API 2.1.26, released 2019-06-26     Make sure unknown extensions don't cause errors 2.1.25, released 2019-06-26
hlint.cabal view
@@ -1,7 +1,7 @@ cabal-version:      >= 1.18 build-type:         Simple name:               hlint-version:            2.1.26+version:            2.2 license:            BSD3 license-file:       LICENSE category:           Development
src/Language/Haskell/HLint3.hs view
@@ -1,125 +1,7 @@-{-# LANGUAGE PatternGuards, RecordWildCards #-} --- | /WARNING: This module represents a previous version of the HLint API./---   /Please use "Language.Haskell.HLint4" instead./+-- | A reexport of "Language.Haskell.HLint4" for compatibility purposes. module Language.Haskell.HLint3(-    hlint, applyHints,-    -- * Idea data type-    Idea(..), Severity(..), Note(..),-    -- * Settings-    Classify(..),-    getHLintDataDir, autoSettings, argsSettings,-    findSettings, readSettingsFile,-    -- * Hints-    HintBuiltin(..), HintRule(..),-    Hint(..), resolveHints,-    -- * Scopes-    Scope, scopeCreate, scopeMatch, scopeMove,-    -- * Haskell-src-exts-    parseModuleEx, defaultParseFlags, parseFlagsAddFixities, ParseError(..), ParseFlags(..), CppFlags(..)+    module Language.Haskell.HLint4     ) where -import Config.Type-import Config.Read-import Idea-import Apply-import HLint-import HSE.All hiding (parseModuleEx)-import qualified HSE.All as H-import Hint.All-import CmdLine-import Paths_hlint--import Data.List.Extra-import Data.Maybe-import System.FilePath-import Data.Functor-import Prelude----- | Get the Cabal configured data directory of HLint.-getHLintDataDir :: IO FilePath-getHLintDataDir = getDataDir----- | The function produces a tuple containg 'ParseFlags' (for 'parseModuleEx'),---   and 'Classify' and 'Hint' for 'applyHints'.---   It approximates the normal HLint configuration steps, roughly:------ 1. Use 'findSettings' with 'readSettingsFile' to find and load the HLint settings files.------ 1. Use 'parseFlagsAddFixities' and 'resolveHints' to transform the outputs of 'findSettings'.------   If you want to do anything custom (e.g. using a different data directory, storing intermediate outputs,---   loading hints from a database) you are expected to copy and paste this function, then change it to your needs.-autoSettings :: IO (ParseFlags, [Classify], Hint)-autoSettings = do-    (fixities, classify, hints) <- findSettings (readSettingsFile Nothing) Nothing-    return (parseFlagsAddFixities fixities defaultParseFlags, classify, resolveHints hints)----- | A version of 'autoSettings' which respects some of the arguments supported by HLint.---   If arguments unrecognised by HLint are used it will result in an error.---   Arguments which have no representation in the return type are silently ignored.-argsSettings :: [String] -> IO (ParseFlags, [Classify], Hint)-argsSettings args = do-    cmd <- getCmd args-    case cmd of-        CmdMain{..} -> do-            -- FIXME: Two things that could be supported (but aren't) are 'cmdGivenHints' and 'cmdWithHints'.-            (_,settings) <- readAllSettings args cmd-            let (fixities, classify, hints) = splitSettings settings-            let flags = parseFlagsSetLanguage (cmdExtensions cmd) $ parseFlagsAddFixities fixities $-                        defaultParseFlags{cppFlags = cmdCpp cmd}-            let ignore = [Classify Ignore x "" "" | x <- cmdIgnore]-            return (flags, classify ++ ignore, resolveHints hints)-        _ -> error "Can only invoke autoSettingsArgs with the root process"----- | Given a directory (or 'Nothing' to imply 'getHLintDataDir'), and a module name---   (e.g. @HLint.Default@), find the settings file associated with it, returning the---   name of the file, and (optionally) the contents.------   This function looks for all settings files starting with @HLint.@ in the directory---   argument, and all other files relative to the current directory.-readSettingsFile :: Maybe FilePath -> String -> IO (FilePath, Maybe String)-readSettingsFile dir x-    | takeExtension x `elem` [".yml",".yaml"] = do-        dir <- maybe getHLintDataDir return dir-        return (dir </> x, Nothing)-    | Just x <- "HLint." `stripPrefix` x = do-        dir <- maybe getHLintDataDir return dir-        return (dir </> x <.> "hs", Nothing)-    | otherwise = return (x <.> "hs", Nothing)----- | Given a function to load a module (typically 'readSettingsFile'), and a module to start from---   (defaults to @hlint.yaml@) find the information from all settings files.-findSettings :: (String -> IO (FilePath, Maybe String)) -> Maybe String -> IO ([Fixity], [Classify], [Either HintBuiltin HintRule])-findSettings load start = do-    (file,contents) <- load $ fromMaybe "hlint.yaml" start-    splitSettings <$> readFilesConfig [(file,contents)]---- | Split a list of 'Setting' for separate use in parsing and hint resolution-splitSettings :: [Setting] -> ([Fixity], [Classify], [Either HintBuiltin HintRule])-splitSettings xs =-    ([x | Infix x <- xs]-    ,[x | SettingClassify x <- xs]-    ,[Right x | SettingMatchExp x <- xs] ++ map Left [minBound..maxBound])----- | 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. This version uses both hs-src-exts AND ghc-lib.-parseModuleEx :: ParseFlags -> FilePath -> Maybe String -> IO (Either ParseError (Module SrcSpanInfo, [Comment]))-parseModuleEx flags file str = fmap pm_hsext <$> H.parseModuleEx flags file str----- | Snippet from the documentation, if this changes, update the documentation-_docs :: IO ()-_docs = do-    (flags, classify, hint) <- autoSettings-    Right (m, c) <- parseModuleEx flags "MyFile.hs" Nothing-    print $ applyHints classify hint [(m, c)]+import Language.Haskell.HLint4