-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell STatic ANalyser
--   
--   Stan is a Haskell <b>ST</b>atic <b>AN</b>alysis CLI tool. See
--   <a>README.md</a> for more details.
@package stan
@version 0.0.0.0


-- | <b>Category</b> — a type of <a>Inspection</a>.
module Stan.Category

-- | A type of the inspection.
newtype Category
Category :: Text -> Category
[unCategory] :: Category -> Text

-- | Show <a>Category</a> in a human-friendly format.
prettyShowCategory :: Category -> Text

-- | The list of all available Stan <a>Category</a>s.
stanCategories :: [Category]

-- | <tt>AntiPattern</tt> category of Stan inspections.
antiPattern :: Category

-- | <tt>Infinite</tt> category of Stan inspections.
infinite :: Category

-- | <tt>List</tt> category of Stan inspections.
list :: Category

-- | <tt>Partial</tt> category of Stan inspections.
partial :: Category

-- | <tt>SpaceLeak</tt> category of Stan inspections.
spaceLeak :: Category

-- | <tt>Syntax</tt> category of Stan inspections. Usually used in
--   <a>Style</a> inspections.
syntax :: Category

-- | <tt>Unsafe</tt> category of Stan inspections.
unsafe :: Category
instance Data.Hashable.Class.Hashable Stan.Category.Category
instance GHC.Classes.Eq Stan.Category.Category
instance GHC.Show.Show Stan.Category.Category


-- | Safe <a>Id</a> representation.
module Stan.Core.Id

-- | A wrapper around the textual value to safely represent IDs for
--   different structures by using a phantom parameter.
newtype Id a
Id :: Text -> Id a
[unId] :: Id a -> Text

-- | A type alias for the situations when we don't care about the parameter
--   of <a>Id</a> but don't want to deal with type variables.
type AnyId = Id ()

-- | Unsafe cast of <a>Id</a>. Implementation uses smart trick to enforce
--   usage always with <tt>TypeApplications</tt>.
castId :: forall to from to'. (to == to') ~ 'True => Id from -> Id to'
instance Data.Hashable.Class.Hashable (Stan.Core.Id.Id a)
instance GHC.Classes.Ord (Stan.Core.Id.Id a)
instance GHC.Classes.Eq (Stan.Core.Id.Id a)
instance GHC.Show.Show (Stan.Core.Id.Id a)


-- | Extra functions to work with lists.
module Stan.Core.List

-- | Checks that two lists have the same length and that a given binary
--   predicate returns <a>True</a> on each corresponding pair of elements.
--   
--   <pre>
--   &gt;&gt;&gt; checkWith (==) [] []
--   True
--   
--   &gt;&gt;&gt; checkWith (==) [1, 2] [1, 2]
--   True
--   
--   &gt;&gt;&gt; checkWith (==) [1, 2] [2, 1]
--   False
--   
--   &gt;&gt;&gt; checkWith (==) [1, 2] [1]
--   False
--   </pre>
checkWith :: (a -> b -> Bool) -> [a] -> [b] -> Bool

-- | Returns list all element pairs without the following properties:
--   
--   <ul>
--   <li>No element with itself: <tt>(x, x)</tt></li>
--   <li>Only one of <tt>(x, y)</tt> and <tt>(y, x)</tt> will be in the
--   result</li>
--   </ul>
--   
--   In other words, it's like taking the cross product of the list with
--   itself and then keeping only the half of that without the diagonal.
--   
--   <pre>
--   &gt;&gt;&gt; foo [1..3]
--   [(1, 2), (1, 3), (2, 3)]
--   </pre>
nonRepeatingPairs :: [a] -> [(a, a)]


-- | Environment variables for <tt>stan</tt>.
module Stan.EnvVars
newtype EnvVars
EnvVars :: TaggedTrial Text Bool -> EnvVars
[envVarsUseDefaultConfigFile] :: EnvVars -> TaggedTrial Text Bool
getEnvVars :: IO EnvVars
envVarsToText :: EnvVars -> Text


-- | Module that contains code that should trigger various beautiful Stan
--   inspections :)
module Stan.Example


-- | Compatibility module for GHC types and functions. Reexports all
--   required API to work with the GHC API.
module Stan.Ghc.Compat

-- | A Module is a pair of a <a>UnitId</a> and a <a>ModuleName</a>.
--   
--   Module variables (i.e. <tt><a>H</a></tt>) which can be instantiated to
--   a specific module at some later point in time are represented with
--   <a>moduleUnitId</a> set to <a>holeUnitId</a> (this allows us to avoid
--   having to make <a>moduleUnitId</a> a partial operation.)
data Module

-- | A ModuleName is essentially a simple string, e.g. <tt>Data.List</tt>.
data ModuleName
moduleNameString :: ModuleName -> String
moduleName :: Module -> ModuleName

-- | Get a string representation of a <a>Module</a> that's unique and
--   stable across recompilations. eg.
--   "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"
moduleStableString :: Module -> String
moduleUnitId :: Module -> UnitId

-- | A unique, unambiguous name for something, containing information about
--   where that thing originated.
data Name
isExternalName :: Name -> Bool

-- | Test if the <a>OccName</a> is that for any operator (whether it is a
--   data constructor or variable or whatever)
isSymOcc :: OccName -> Bool
nameModule :: HasDebugCallStack => Name -> Module
nameOccName :: Name -> OccName

-- | Get a string representation of a <a>Name</a> that's unique and stable
--   across recompilations. Used for deterministic generation of binds for
--   derived instances. eg.
--   "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"
nameStableString :: Name -> String
occNameString :: OccName -> String

-- | A <a>RealSrcSpan</a> delimits a portion of a text file. It could be
--   represented by a pair of (line,column) coordinates, but in fact we
--   optimise slightly by using more compact representations for
--   single-line and zero-length spans, both of which are quite common.
--   
--   The end position is defined to be the column <i>after</i> the end of
--   the span. That is, a span of (1,1)-(1,2) is one character long, and a
--   span of (1,1)-(1,1) is zero characters long.
--   
--   Real Source Span
data RealSrcSpan
srcSpanEndCol :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanStartLine :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanFile :: RealSrcSpan -> FastString

-- | Argument Flag
--   
--   Is something required to appear in source Haskell (<a>Required</a>),
--   permitted by request (<a>Specified</a>) (visible type application), or
--   prohibited entirely from appearing in source Haskell
--   (<a>Inferred</a>)? See Note [VarBndrs, TyCoVarBinders, TyConBinders,
--   and visibility] in TyCoRep
data ArgFlag
Inferred :: ArgFlag
Specified :: ArgFlag
Required :: ArgFlag

-- | Records what things are "available", i.e. in scope
data AvailInfo

-- | An ordinary identifier in scope
Avail :: Name -> AvailInfo

-- | A type or class in scope
--   
--   The <b>AvailTC Invariant</b>: If the type or class is itself to be in
--   scope, it must be <i>first</i> in this list. Thus, typically:
--   
--   <pre>
--   AvailTC Eq [Eq, ==, \/=] []
--   </pre>
AvailTC :: Name -> [Name] -> [FieldLabel] -> AvailInfo

-- | A <a>FastString</a> is an array of bytes, hashed to support fast O(1)
--   comparison. It is also associated with a character encoding, so that
--   we know how to convert a <a>FastString</a> to the local encoding, or
--   to the Z-encoding used by the compiler internally.
--   
--   <a>FastString</a>s support a memoized conversion to the Z-encoding via
--   zEncodeFS.
data FastString

-- | Fields in an algebraic record type
data FieldLbl a
FieldLabel :: FieldLabelString -> Bool -> a -> FieldLbl a

-- | User-visible label of the field
[flLabel] :: FieldLbl a -> FieldLabelString

-- | Was DuplicateRecordFields on in the defining module for this datatype?
[flIsOverloaded] :: FieldLbl a -> Bool

-- | Record selector function
[flSelector] :: FieldLbl a -> a
data IfaceTyCon
IfaceTyCon :: IfExtName -> IfaceTyConInfo -> IfaceTyCon
[ifaceTyConName] :: IfaceTyCon -> IfExtName
[ifaceTyConInfo] :: IfaceTyCon -> IfaceTyConInfo
data IfaceTyConInfo
IfaceTyConInfo :: PromotionFlag -> IfaceTyConSort -> IfaceTyConInfo
[ifaceTyConIsPromoted] :: IfaceTyConInfo -> PromotionFlag
[ifaceTyConSort] :: IfaceTyConInfo -> IfaceTyConSort

-- | The various types of TyCons which have special, built-in syntax.
data IfaceTyConSort

-- | a regular tycon
IfaceNormalTyCon :: IfaceTyConSort

-- | e.g. <tt>(a, b, c)</tt> or <tt>()</tt>. The arity is the tuple width,
--   not the tycon arity (which is twice the width in the case of unboxed
--   tuples).
IfaceTupleTyCon :: !Arity -> !TupleSort -> IfaceTyConSort

-- | e.g. <tt>(a | b | c)</tt>
IfaceSumTyCon :: !Arity -> IfaceTyConSort

-- | A heterogeneous equality TyCon (i.e. eqPrimTyCon, eqReprPrimTyCon,
--   heqTyCon) that is actually being applied to two types of the same
--   kind. This affects pretty-printing only: see Note [Equality predicates
--   in IfaceType]
IfaceEqualityTyCon :: IfaceTyConSort
data IfaceTyLit
IfaceNumTyLit :: Integer -> IfaceTyLit
IfaceStrTyLit :: FastString -> IfaceTyLit

-- | Is a TyCon a promoted data constructor or just a normal type
--   constructor?
data PromotionFlag
NotPromoted :: PromotionFlag
IsPromoted :: PromotionFlag
data TupleSort
BoxedTuple :: TupleSort
UnboxedTuple :: TupleSort
ConstraintTuple :: TupleSort


-- | Wrapper around Haskell module names and conversion functions for GHC
--   types.
module Stan.Core.ModuleName

-- | Wrapper around Haskell module name.
newtype ModuleName
ModuleName :: Text -> ModuleName
[unModuleName] :: ModuleName -> Text

-- | Extract <a>ModuleName</a> from <a>Module</a>.
fromGhcModule :: Module -> ModuleName

-- | Convert <a>ModuleName</a> to <a>ModuleName</a>.
fromGhcModuleName :: ModuleName -> ModuleName
instance Data.String.IsString Stan.Core.ModuleName.ModuleName
instance Data.Hashable.Class.Hashable Stan.Core.ModuleName.ModuleName
instance GHC.Classes.Eq Stan.Core.ModuleName.ModuleName
instance GHC.Show.Show Stan.Core.ModuleName.ModuleName


-- | Compatibility module for HIE types from GHC API. Reexports all
--   required API to work with HIE types.
module Stan.Hie.Compat

-- | Different contexts under which identifiers exist
data ContextInfo

-- | regular variable
Use :: ContextInfo
MatchBind :: ContextInfo

-- | import/export
IEThing :: IEType -> ContextInfo
TyDecl :: ContextInfo

-- | Value binding
ValBind :: BindType -> Scope -> Maybe Span -> ContextInfo

-- | Pattern binding
--   
--   This case is tricky because the bound identifier can be used in two
--   distinct scopes. Consider the following example (with
--   <tt>-XViewPatterns</tt>)
--   
--   <pre>
--   do (b, a, (a -&gt; True)) &lt;- bar
--      foo a
--   </pre>
--   
--   The identifier <tt>a</tt> has two scopes: in the view pattern <tt>(a
--   -&gt; True)</tt> and in the rest of the <tt>do</tt>-block in <tt>foo
--   a</tt>.
PatternBind :: Scope -> Scope -> Maybe Span -> ContextInfo
ClassTyDecl :: Maybe Span -> ContextInfo

-- | Declaration
Decl :: DeclType -> Maybe Span -> ContextInfo

-- | Type variable
TyVarBind :: Scope -> TyVarScope -> ContextInfo

-- | Record field
RecField :: RecFieldContext -> Maybe Span -> ContextInfo

-- | A list of type arguments along with their respective visibilities (ie.
--   is this an argument that would return <a>True</a> for
--   <tt>isVisibleArgFlag</tt>?).
newtype HieArgs a
HieArgs :: [(Bool, a)] -> HieArgs a
data HieAST a
Node :: NodeInfo a -> Span -> [HieAST a] -> HieAST a
[nodeInfo] :: HieAST a -> NodeInfo a
[nodeSpan] :: HieAST a -> Span
[nodeChildren] :: HieAST a -> [HieAST a]

-- | Mapping from filepaths (represented using <a>FastString</a>) to the
--   corresponding AST
newtype HieASTs a
HieASTs :: Map FastString (HieAST a) -> HieASTs a
[getAsts] :: HieASTs a -> Map FastString (HieAST a)

-- | GHC builds up a wealth of information about Haskell source as it
--   compiles it. <tt>.hie</tt> files are a way of persisting some of this
--   information to disk so that external tools that need to work with
--   haskell source don't need to parse, typecheck, and rename all over
--   again. These files contain:
--   
--   <ul>
--   <li>a simplified AST<ul><li>nodes are annotated with source positions
--   and types</li><li>identifiers are annotated with scope
--   information</li></ul></li>
--   <li>the raw bytes of the initial Haskell source</li>
--   </ul>
--   
--   Besides saving compilation cycles, <tt>.hie</tt> files also offer a
--   more stable interface than the GHC API.
data HieFile
HieFile :: FilePath -> Module -> Array TypeIndex HieTypeFlat -> HieASTs TypeIndex -> [AvailInfo] -> ByteString -> HieFile

-- | Initial Haskell source file path
[hie_hs_file] :: HieFile -> FilePath

-- | The module this HIE file is for
[hie_module] :: HieFile -> Module

-- | Types referenced in the <a>hie_asts</a>.
--   
--   See Note [Efficient serialization of redundant type info]
[hie_types] :: HieFile -> Array TypeIndex HieTypeFlat

-- | Type-annotated abstract syntax trees
[hie_asts] :: HieFile -> HieASTs TypeIndex

-- | The names that this module exports
[hie_exports] :: HieFile -> [AvailInfo]

-- | Raw bytes of the initial Haskell source
[hie_hs_src] :: HieFile -> ByteString

-- | A flattened version of <tt>Type</tt>.
--   
--   See Note [Efficient serialization of redundant type info]
data HieType a
HTyVarTy :: Name -> HieType a
HAppTy :: a -> HieArgs a -> HieType a
HTyConApp :: IfaceTyCon -> HieArgs a -> HieType a
HForAllTy :: ((Name, a), ArgFlag) -> a -> HieType a
HFunTy :: a -> a -> HieType a

-- | type with constraint: <tt>t1 =&gt; t2</tt> (see <a>IfaceDFunTy</a>)
HQualTy :: a -> a -> HieType a
HLitTy :: IfaceTyLit -> HieType a
HCastTy :: a -> HieType a
HCoercionTy :: HieType a
type HieTypeFlat = HieType TypeIndex

-- | Types of imports and exports
data IEType
Import :: IEType
ImportAs :: IEType
ImportHiding :: IEType
Export :: IEType
type Identifier = Either ModuleName Name

-- | Information associated with every identifier
--   
--   We need to include types with identifiers because sometimes multiple
--   identifiers occur in the same span(Overloaded Record Fields and so on)
data IdentifierDetails a
IdentifierDetails :: Maybe a -> Set ContextInfo -> IdentifierDetails a
[identType] :: IdentifierDetails a -> Maybe a
[identInfo] :: IdentifierDetails a -> Set ContextInfo

-- | The information stored in one AST node.
--   
--   The type parameter exists to provide flexibility in representation of
--   types (see Note [Efficient serialization of redundant type info]).
data NodeInfo a
NodeInfo :: Set (FastString, FastString) -> [a] -> NodeIdentifiers a -> NodeInfo a

-- | (name of the AST node constructor, name of the AST node Type)
[nodeAnnotations] :: NodeInfo a -> Set (FastString, FastString)

-- | The Haskell types of this node, if any.
[nodeType] :: NodeInfo a -> [a]

-- | All the identifiers and their details
[nodeIdentifiers] :: NodeInfo a -> NodeIdentifiers a
type TypeIndex = Int
data HieFileResult

-- | Read a <a>HieFile</a> from a <a>FilePath</a>. Can use an existing
--   <a>NameCache</a>.
readHieFile :: NameCache -> FilePath -> IO (HieFileResult, NameCache)

-- | The NameCache makes sure that there is just one Unique assigned for
--   each original name; i.e. (module-name, occ-name) pair and provides
--   something of a lookup mechanism for those names.
data NameCache

-- | Return a function to atomically update the name cache.
initNameCache :: UniqSupply -> [Name] -> NameCache

-- | Create a unique supply out of thin air. The character given must be
--   distinct from those of all calls to this function in the compiler for
--   the values generated to be truly unique.
mkSplitUniqSupply :: Char -> IO UniqSupply


-- | Functions to work with cabal files and cabal extension maps.
module Stan.Cabal

-- | From a given path to cabal files and <a>HieFile</a>s create the map
--   from modules (that are in .cabal file) to the resulting parsed
--   extensions for each.
createCabalExtensionsMap :: [FilePath] -> [HieFile] -> IO (Map FilePath (Either ExtensionsError ParsedExtensions))

-- | Gets the list of <tt>.cabal</tt> file paths that were used in the
--   project.
usedCabalFiles :: [FilePath] -> IO [FilePath]
mergeParsedExtensions :: Either ExtensionsError ParsedExtensions -> Either ExtensionsError ParsedExtensions -> ExtensionsResult


-- | <tt>stan</tt> build information.
module Stan.Info

-- | <tt>stan</tt> version information.
data StanVersion
StanVersion :: !String -> !String -> !String -> StanVersion
[svVersion] :: StanVersion -> !String
[svGitRevision] :: StanVersion -> !String
[svCommitDate] :: StanVersion -> !String

-- | Current <tt>stan</tt> version information.
stanVersion :: StanVersion

-- | Colourful pretty <a>StanVersion</a> representation used in the
--   <tt>CLI</tt>.
prettyStanVersion :: StanVersion -> String

-- | Contains all <tt>stan</tt> System information
data StanSystem
StanSystem :: !String -> !String -> !String -> !String -> StanSystem
[ssOs] :: StanSystem -> !String
[ssArch] :: StanSystem -> !String
[ssCompiler] :: StanSystem -> !String
[ssCompilerVersion] :: StanSystem -> !String

-- | All system info for the project
stanSystem :: StanSystem

-- | Data from different environment resources:
--   
--   <ul>
--   <li>Environment variables</li>
--   <li>Used TOML configuration files</li>
--   <li>Command Line arguments</li>
--   </ul>
data StanEnv
StanEnv :: !Text -> ![FilePath] -> ![String] -> StanEnv
[seEnvVars] :: StanEnv -> !Text
[seTomlFiles] :: StanEnv -> ![FilePath]
[seCliArgs] :: StanEnv -> ![String]
data ProjectInfo
ProjectInfo :: !String -> ![FilePath] -> !FilePath -> !Int -> ProjectInfo
[piName] :: ProjectInfo -> !String
[piCabalFiles] :: ProjectInfo -> ![FilePath]
[piHieDir] :: ProjectInfo -> !FilePath
[piFileNumber] :: ProjectInfo -> !Int
instance GHC.Classes.Eq Stan.Info.ProjectInfo
instance GHC.Show.Show Stan.Info.ProjectInfo
instance GHC.Classes.Eq Stan.Info.StanEnv
instance GHC.Show.Show Stan.Info.StanEnv
instance GHC.Classes.Eq Stan.Info.StanSystem
instance GHC.Show.Show Stan.Info.StanSystem
instance GHC.Classes.Eq Stan.Info.StanVersion
instance GHC.Show.Show Stan.Info.StanVersion


-- | Data types and functions for working with meta information.
module Stan.NameMeta

-- | Meta information about function/type.
data NameMeta
NameMeta :: !Text -> !ModuleName -> !Text -> NameMeta
[nameMetaPackage] :: NameMeta -> !Text
[nameMetaModuleName] :: NameMeta -> !ModuleName
[nameMetaName] :: NameMeta -> !Text

-- | Pretty show <a>NameMeta</a> in the following format:
--   <tt>package/module/name</tt>.
prettyShowNameMeta :: NameMeta -> Text

-- | Check if <a>NameMeta</a> is identical to <a>Name</a>.
compareNames :: NameMeta -> Name -> Bool

-- | Check whether HIE <a>Identifier</a> with details is a given
--   <a>NameMeta</a>.
hieMatchNameMeta :: NameMeta -> (Identifier, IdentifierDetails TypeIndex) -> Bool

-- | Check if the given <a>HieAST</a> node is identifier equal to the given
--   <a>NameMeta</a>.
hieFindIdentifier :: NameMeta -> HieAST TypeIndex -> Maybe NameMeta

-- | Create <a>NameMeta</a> for a function from the <tt>base</tt> package
--   and a given <a>ModuleName</a>. module.
baseNameFrom :: Text -> ModuleName -> NameMeta
infix 8 `baseNameFrom`

-- | Create <a>NameMeta</a> for a function from the <tt>base</tt> package
--   and the <a>GHC.List</a> module.
mkBaseListMeta :: Text -> NameMeta

-- | Create <a>NameMeta</a> for a function from the <tt>base</tt> package
--   and the <a>Data.OldList</a> module.
mkBaseOldListMeta :: Text -> NameMeta

-- | Create <a>NameMeta</a> for a function from the <tt>base</tt> package
--   and the <a>Data.Foldable</a> module.
mkBaseFoldableMeta :: Text -> NameMeta

-- | Create <a>NameMeta</a> for a function from the
--   <tt>unordered-containers</tt> package and a given <a>ModuleName</a>
--   module.
unorderedNameFrom :: Text -> ModuleName -> NameMeta
infix 8 `unorderedNameFrom`

-- | Create <a>NameMeta</a> for a function from the <tt>text</tt> package
--   and a given <a>ModuleName</a> module.
textNameFrom :: Text -> ModuleName -> NameMeta
infix 8 `textNameFrom`

-- | Create <a>NameMeta</a> for a function from the <tt>ghc-prim</tt>
--   package and a given <a>ModuleName</a> module.
ghcPrimNameFrom :: Text -> ModuleName -> NameMeta
infix 8 `ghcPrimNameFrom`

-- | <a>NameMeta</a> for primitive types.
primTypeMeta :: Text -> NameMeta
instance GHC.Classes.Eq Stan.NameMeta.NameMeta
instance GHC.Show.Show Stan.NameMeta.NameMeta


-- | Useful debugging and printing utilities for HIE types. They are
--   implemented in two ways:
--   
--   <ol>
--   <li>Using derived <a>Show</a> instances.</li>
--   <li>Using <tt>ghc</tt> pretty-printing.</li>
--   </ol>
--   
--   To make full use of derived <a>Show</a> instances, add the
--   <tt>pretty-simple</tt> package to dependencies and use the
--   <tt>pPrint</tt> function from the <tt>Text.Pretty.Simple</tt> module.
module Stan.Hie.Debug
debugHieFile :: FilePath -> [HieFile] -> IO ()
instance GHC.Show.Show HieTypes.HieFile
instance GHC.Show.Show a => GHC.Show.Show (HieTypes.HieType a)
instance GHC.Show.Show a => GHC.Show.Show (HieTypes.HieAST a)
instance GHC.Show.Show a => GHC.Show.Show (HieTypes.HieASTs a)
instance GHC.Show.Show a => GHC.Show.Show (HieTypes.HieArgs a)
instance GHC.Show.Show a => GHC.Show.Show (HieTypes.NodeInfo a)
instance GHC.Show.Show a => GHC.Show.Show (HieTypes.IdentifierDetails a)
instance GHC.Show.Show IfaceType.IfaceTyCon
instance GHC.Show.Show IfaceType.IfaceTyConInfo
instance GHC.Show.Show IfaceType.IfaceTyConSort
instance GHC.Show.Show IfaceType.IfaceTyLit
instance GHC.Show.Show BasicTypes.PromotionFlag
instance GHC.Show.Show BasicTypes.TupleSort
instance GHC.Show.Show Var.ArgFlag
instance GHC.Show.Show Avail.AvailInfo
instance GHC.Show.Show a => GHC.Show.Show (FieldLabel.FieldLbl a)
instance GHC.Show.Show Module.Module
instance GHC.Show.Show Module.ModuleName
instance GHC.Show.Show Name.Name


-- | Embedded DSL for patterns (AST and Type). Implemented using the
--   <i>Final Taggless</i> approach.
module Stan.Pattern.Edsl

-- | Common interface for <a>Bool</a>-like parts of patterns. Allows to
--   write composable and reusable complex pattern definitions from smaller
--   pieces.
--   
--   Laws (in terms of matching functions that return <a>Bool</a>):
--   
--   <ul>
--   <li><pre><a>(?)</a> ≡ <a>True</a></pre></li>
--   <li><pre><a>neg</a> <a>(?)</a> ≡ <a>False</a></pre></li>
--   <li><pre><a>(?)</a> <a>|||</a> x ≡ x <a>|||</a> <a>(?)</a> ≡
--   <a>True</a></pre></li>
--   <li><pre><a>(?)</a> <a>&amp;&amp;&amp;</a> x ≡ x
--   <a>&amp;&amp;&amp;</a> <a>(?)</a> ≡ x</pre></li>
--   </ul>
class PatternBool a

-- | Anything. Matching should always return <a>True</a>.
(?) :: PatternBool a => a

-- | Negation. Inverses the argument.
neg :: PatternBool a => a -> a

-- | Or-pattern. Choice.
(|||) :: PatternBool a => a -> a -> a

-- | And-pattern. Both.
(&&&) :: PatternBool a => a -> a -> a
infixr 2 |||
infixr 3 &&&


-- | Patterns for types and type search.
module Stan.Pattern.Type

-- | Query pattern used to search types in HIE AST.
data PatternType

-- | Argument, type or constructor:
--   
--   TODO: table
PatternTypeName :: !NameMeta -> ![PatternType] -> PatternType

-- | Function pattern.
PatternTypeFun :: !PatternType -> !PatternType -> PatternType

-- | Type wildcard, matches anything.
PatternTypeAnything :: PatternType

-- | Choice between patterns. Should match either of them.
PatternTypeOr :: !PatternType -> !PatternType -> PatternType

-- | Union of patterns. Should match both of them.
PatternTypeAnd :: !PatternType -> !PatternType -> PatternType

-- | Negation of pattern. Should match everything except this pattern.
PatternTypeNeg :: !PatternType -> PatternType

-- | Short operator alias for <tt>PatternFun</tt>.
(|->) :: PatternType -> PatternType -> PatternType
infixr 4 |->

-- | Short operator alias for <a>PatternTypeName</a>.
(|::) :: NameMeta -> [PatternType] -> PatternType
infix 5 |::

-- | <a>PatternType</a> for list <tt>[a]</tt> or <tt><a>String</a></tt>.
listPattern :: PatternType

-- | <a>PatternType</a> for <a>NonEmpty</a>.
nonEmptyPattern :: PatternType

-- | <a>PatternType</a> for <tt>[a] -&gt; _</tt> or <tt>String -&gt;
--   _</tt>.
listFunPattern :: PatternType

-- | <a>PatternType</a> for <a>Integer</a>.
integerPattern :: PatternType

-- | <a>PatternType</a> for <a>Natural</a>.
naturalPattern :: PatternType
charPattern :: PatternType

-- | <a>PatternType</a> for <a>String</a>.
stringPattern :: PatternType

-- | <a>PatternType</a> for <a>Text</a>.
textPattern :: PatternType

-- | List of types for <tt>STAN-0207</tt>.
foldableTypesPatterns :: NonEmpty PatternType

-- | Type patterns for the <a>Foldable</a> typeclass methods. Represented
--   as a non-empty list of pairs:
--   
--   <ul>
--   <li>Method name</li>
--   <li>Function from type to pattern (where things like <a>Maybe</a>,
--   <a>Either</a> should be)</li>
--   </ul>
foldableMethodsPatterns :: NonEmpty (NameMeta, PatternType -> PatternType)
instance GHC.Classes.Eq Stan.Pattern.Type.PatternType
instance GHC.Show.Show Stan.Pattern.Type.PatternType
instance Stan.Pattern.Edsl.PatternBool Stan.Pattern.Type.PatternType


-- | Patterns for AST and syntax tree nodes search.
module Stan.Pattern.Ast

-- | Query pattern used to search AST nodes in HIE AST. This data type
--   tries to mirror HIE AST to each future matching, so it's quite
--   low-level, but helper functions are provided.
data PatternAst

-- | Integer constant in code.
PatternAstConstant :: !Literal -> PatternAst

-- | Name of a specific function, variable or data type.
PatternAstName :: !NameMeta -> !PatternType -> PatternAst

-- | Variable name.
PatternAstVarName :: !String -> PatternAst

-- | Set of context info (pairs of tags) | AST node with tags for current
--   node and children patterns. This pattern should match the node
--   exactly.
PatternAstNode :: !Set (FastString, FastString) -> PatternAst
PatternAstNodeExact :: !Set (FastString, FastString) -> ![PatternAst] -> PatternAst
PatternAstAnything :: PatternAst

-- | Choice between patterns. Should match either of them.
PatternAstOr :: !PatternAst -> !PatternAst -> PatternAst

-- | Union of patterns. Should match both of them.
PatternAstAnd :: !PatternAst -> !PatternAst -> PatternAst

-- | Negation of pattern. Should match everything except this pattern.
PatternAstNeg :: !PatternAst -> PatternAst
data Literal
ExactNum :: !Int -> Literal
ExactStr :: !ByteString -> Literal
PrefixStr :: !ByteString -> Literal
ContainStr :: !ByteString -> Literal
AnyLiteral :: Literal

-- | Function that creates <a>PatternAst</a> from the given non-empty list
--   of pairs <a>NameMeta</a> and <a>PatternType</a>.
--   
--   If the list contains only one <a>PatternType</a> then it is simple
--   <a>PatternAstName</a>. Else it is <a>PatternAstOr</a> of all such
--   <a>PatternAstName</a>s.
namesToPatternAst :: NonEmpty (NameMeta, PatternType) -> PatternAst

-- | Like <a>namesToPatternAst</a> but doesn't care about types.
anyNamesToPatternAst :: NonEmpty NameMeta -> PatternAst

-- | <tt>app f x</tt> is a pattern for function application <tt>f x</tt>.
app :: PatternAst -> PatternAst -> PatternAst

-- | <tt>opApp x op y</tt> is a pattern for operator application <tt>x
--   <tt>op</tt> y</tt>.
opApp :: PatternAst -> PatternAst -> PatternAst -> PatternAst

-- | Constructor of a plain data type or newtype. Children of node that
--   matches this pattern are constructor fields.
constructor :: PatternAst

-- | <tt>data</tt> or <tt>newtype</tt> declaration.
dataDecl :: PatternAst

-- | Pattern for the top-level fixity declaration:
--   
--   <pre>
--   infixr 7 ***, +++, ???
--   </pre>
fixity :: PatternAst

-- | Pattern for the function definition:
--   
--   <pre>
--   foo x y = ...
--   </pre>
fun :: PatternAst

-- | Pattern for a single <tt>guard</tt> branch:
--   
--   <pre>
--   | x &lt; y = ...
--   </pre>
guardBranch :: PatternAst

-- | Lazy data type field. Comes in two shapes:
--   
--   <ol>
--   <li>Record field, like: <tt>foo :: Text</tt></li>
--   <li>Simple type: <tt>Int</tt></li>
--   </ol>
lazyField :: PatternAst

-- | <tt>range a b</tt> is a pattern for <tt>[a .. b]</tt>
range :: PatternAst -> PatternAst -> PatternAst

-- | Pattern for the right-hand-side. Usually an equality sign.
--   
--   <pre>
--   foo = baz
--   </pre>
rhs :: PatternAst

-- | Pattern for tuples:
--   
--   <ul>
--   <li>Type signatures: foo :: (Int, Int, Int, Int)</li>
--   <li>Literals: (True, 0, [], Nothing)</li>
--   </ul>
tuple :: PatternAst

-- | Pattern for the function type signature declaration:
--   
--   <pre>
--   foo :: Some -&gt; Type
--   </pre>
typeSig :: PatternAst

-- | <a>case'</a> is a pattern for <tt>case EXP of</tt> expression (not
--   considering branches).
case' :: PatternAst

-- | <a>lambdaCase</a> is a pattern for <tt>case</tt> expression (not
--   considering branches).
lambdaCase :: PatternAst

-- | Pattern to represent one pattern matching branch.
patternMatchBranch :: PatternAst

-- | Pattern to represent right side of the pattern matching, e.g.
--   <tt>-&gt; "foo"</tt>.
patternMatchArrow :: PatternAst -> PatternAst

-- | Pattern to represent one pattern matching branch on <tt>_</tt>.
patternMatch_ :: PatternAst -> PatternAst

-- | Pattern for literals in pattern matching.
--   
--   <b>Note:</b> presents on GHC &gt;=8.10 only.
literalPat :: PatternAst

-- | Pattern for <tt>_</tt> in pattern matching.
--   
--   <b>Note:</b> presents on GHC &gt;=8.10 only.
wildPat :: PatternAst

-- | Annotations for constants: 0, "foo", etc.
literalAnns :: (FastString, FastString)
instance GHC.Classes.Eq Stan.Pattern.Ast.PatternAst
instance GHC.Show.Show Stan.Pattern.Ast.PatternAst
instance GHC.Classes.Eq Stan.Pattern.Ast.Literal
instance GHC.Show.Show Stan.Pattern.Ast.Literal
instance Stan.Pattern.Edsl.PatternBool Stan.Pattern.Ast.PatternAst


-- | Functions to work with <tt>hie</tt> specific parts.
module Stan.Hie

-- | Returns contents of all <tt>.hie</tt> files recursively in the given
--   <tt>hie</tt> directory.
readHieFiles :: FilePath -> IO [HieFile]

-- | Get the number of lines of code in the file by analising
--   <a>HieFile</a>.
countLinesOfCode :: HieFile -> Int

-- | Compare two AST nodes on equality. This is a more relaxed version of
--   the <a>Eq</a> instance for <a>HieAST</a> because it doesn't compare
--   source locations. This function is useful if you want to check whether
--   two AST nodes represent the same AST.
--   
--   This function needs to take the original <a>HieFile</a> because
--   constants are not stored in <a>HieAST</a> and to compare constants we
--   need to compare parts of source code.
eqAst :: forall a. Eq a => HieFile -> HieAST a -> HieAST a -> Bool

-- | Take sub-bytestring according to a given span.
--   
--   TODO: currently works only with single-line spans
slice :: RealSrcSpan -> ByteString -> ByteString


-- | Some <a>Inspection</a>s require to know about types and some mechanism
--   to match types to the given <a>PatternType</a>. This information on
--   types/type expressions is taken from <tt>HIE files</tt> in a more
--   suitable view.
--   
--   Let's take a look at the function <tt>foo</tt>:
--   
--   <pre>
--   foo :: NonEmpty String -&gt; Int
--   </pre>
--   
--   In <tt>HIE</tt> files it will be stored as an <a>Array</a> like this:
--   
--   <pre>
--   1 -&gt; <a>Int</a>      []
--   2 -&gt; <a>String</a>   []
--   3 -&gt; <a>NonEmpty</a> [ 2 ]
--   4 -&gt; FunType    3 1
--   </pre>
--   
--   This module contains an implementation of the process of retrieval of
--   this information from there.
module Stan.Hie.MatchType

-- | Matching function that searches the array of types recursively.
hieMatchPatternType :: Array TypeIndex HieTypeFlat -> PatternType -> TypeIndex -> Bool


-- | Some <a>Inspection</a>s require to know about AST and some mechanism
--   to match parts of syntax tree to the given <a>PatternAst</a>. This
--   information on AST expressions is taken from <tt>HIE files</tt> in a
--   more suitable view.
--   
--   This module contains an implementation of the process of retrieval of
--   AST information from <tt>HIE</tt> files.
module Stan.Hie.MatchAst

-- | Matching function that matches current AST node with a given pattern.
hieMatchPatternAst :: HieFile -> HieAST TypeIndex -> PatternAst -> Bool


-- | Css to be used in the generated HTML in the report.
module Stan.Report.Css
stanCss :: Css


-- | Report settings types.
module Stan.Report.Settings

-- | Settings for produced report.
data ReportSettings
ReportSettings :: !Verbosity -> !ToggleSolution -> ReportSettings
[reportSettingsVerbosity] :: ReportSettings -> !Verbosity
[reportSettingsSolutionVerbosity] :: ReportSettings -> !ToggleSolution
data Verbosity
Verbose :: Verbosity
NonVerbose :: Verbosity
isVerbose :: Verbosity -> Bool

-- | Boolean for showing/hiding solution information of observations.
data ToggleSolution
HideSolution :: ToggleSolution
ShowSolution :: ToggleSolution

-- | Is the toggle option set to <a>HideSolution</a>?
isHidden :: ToggleSolution -> Bool
instance GHC.Show.Show Stan.Report.Settings.ToggleSolution
instance GHC.Show.Show Stan.Report.Settings.Verbosity


-- | This module introduces <a>Severity</a> data type for expressing how
--   severe the message is. Also, it contains useful functions to work with
--   <a>Severity</a>.
module Stan.Severity

-- | Severity level of the inspection.
--   
--   TODO: table
data Severity

-- | Code style issues. Usually harmless.
Style :: Severity

-- | Serious defects that could cause slowness and space leaking.
Performance :: Severity

-- | Human errors in code.
PotentialBug :: Severity

-- | Potential runtime errors on some inputs.
Warning :: Severity

-- | Dangerous behaviour.
Error :: Severity

-- | Description of each <a>Severity</a> level.
severityDescription :: Severity -> Text

-- | Get the colour of the severity level.
severityColour :: Severity -> Text

-- | Show <a>Severity</a> in a human-friendly format.
prettyShowSeverity :: Severity -> Text
instance GHC.Enum.Bounded Stan.Severity.Severity
instance GHC.Enum.Enum Stan.Severity.Severity
instance GHC.Classes.Ord Stan.Severity.Severity
instance GHC.Classes.Eq Stan.Severity.Severity
instance GHC.Read.Read Stan.Severity.Severity
instance GHC.Show.Show Stan.Severity.Severity


-- | <b>Inspection</b> — check or test provided by Stan.
module Stan.Inspection

-- | Data type that represents a check/test, or how we call it
--   <b>inspection</b> that is provided by the Stan tool.
data Inspection
Inspection :: !Id Inspection -> !Text -> !Text -> ![Text] -> !NonEmpty Category -> !Severity -> !InspectionAnalysis -> Inspection
[inspectionId] :: Inspection -> !Id Inspection
[inspectionName] :: Inspection -> !Text
[inspectionDescription] :: Inspection -> !Text
[inspectionSolution] :: Inspection -> ![Text]
[inspectionCategory] :: Inspection -> !NonEmpty Category
[inspectionSeverity] :: Inspection -> !Severity
[inspectionAnalysis] :: Inspection -> !InspectionAnalysis
categoryL :: Lens' Inspection (NonEmpty Category)
descriptionL :: Lens' Inspection Text
solutionL :: Lens' Inspection [Text]
severityL :: Lens' Inspection Severity
analysisL :: Lens' Inspection InspectionAnalysis

-- | Data type that represents all possible types of <tt>stan</tt>
--   inspections in a uniformed way.
data InspectionAnalysis

-- | Find the specific part of the Haskell AST (including specific
--   functions).
FindAst :: !PatternAst -> InspectionAnalysis

-- | Find all operators without matching <tt>infix[r|l]</tt>
Infix :: InspectionAnalysis

-- | Check if the data type has lazy fields
LazyField :: InspectionAnalysis

-- | Usage of tuples with size &gt;= 4
BigTuples :: InspectionAnalysis

-- | Pattern matching on <tt>_</tt> for sum types.
PatternMatchOn_ :: InspectionAnalysis

-- | Replace multiple comparison operations with <a>compare</a>
UseCompare :: InspectionAnalysis

-- | Type alias for the <a>HashMap</a> that contains pairs of inspections
--   <a>Id</a>s and corresponding <a>Inspection</a>s.
type InspectionsMap = HashMap (Id Inspection) Inspection

-- | Sort <a>Inspection</a> by <a>Id</a>
sortById :: InspectionsMap -> [Inspection]

-- | Show <a>Inspection</a> in a human-friendly format.
prettyShowInspection :: Inspection -> Text

-- | Show the short view of a given <a>Inspection</a>.
prettyShowInspectionShort :: Inspection -> Text

-- | Create the MarkDown text for all inspections. The generated MD has a
--   ToC and separate sections for each inspection.
--   
--   This is used to keep the Wiki page of the project up to date.
inspectionsMd :: [Inspection] -> Text
instance GHC.Classes.Eq Stan.Inspection.Inspection
instance GHC.Show.Show Stan.Inspection.Inspection
instance GHC.Classes.Eq Stan.Inspection.InspectionAnalysis
instance GHC.Show.Show Stan.Inspection.InspectionAnalysis


-- | Contains all <a>Inspection</a>s for style improvements.
--   
--   The <b>style</b> inspections are in ranges:
--   
--   <ul>
--   <li><pre>STAN-0301 .. STAN-0400</pre></li>
--   </ul>
module Stan.Inspection.Style

-- | <a>Inspection</a> — missing fixity declaration <tt>STAN-0301</tt>.
stan0301 :: Inspection

-- | <a>Inspection</a> — to big tuples <tt>STAN-0302</tt>.
stan0302 :: Inspection

-- | All anti-pattern <a>Inspection</a>s map from <a>Id</a>s.
styleInspectionsMap :: InspectionsMap


-- | Contains all <a>Inspection</a>s for partial functions.
--   
--   The <b>partial</b> inspections are in ranges:
--   
--   <ul>
--   <li><pre>STAN-0001 .. STAN-0100</pre></li>
--   </ul>
module Stan.Inspection.Partial

-- | <a>Inspection</a> — partial <a>head</a> <tt>STAN-0001</tt>.
stan0001 :: Inspection

-- | <a>Inspection</a> — partial <a>tail</a> <tt>STAN-0002</tt>.
stan0002 :: Inspection

-- | <a>Inspection</a> — partial <a>init</a> <tt>STAN-0003</tt>.
stan0003 :: Inspection

-- | <a>Inspection</a> — partial <a>last</a> <tt>STAN-0004</tt>.
stan0004 :: Inspection

-- | <a>Inspection</a> — partial <a>!!</a> <tt>STAN-0005</tt>.
stan0005 :: Inspection

-- | <a>Inspection</a> — partial <a>cycle</a> <tt>STAN-0006</tt>.
stan0006 :: Inspection

-- | <a>Inspection</a> — partial <a>genericIndex</a> <tt>STAN-0007</tt>.
stan0007 :: Inspection

-- | <a>Inspection</a> — partial <a>fromJust</a> <tt>STAN-0008</tt>.
stan0008 :: Inspection

-- | <a>Inspection</a> — partial <a>read</a> <tt>STAN-0009</tt>.
stan0009 :: Inspection

-- | <a>Inspection</a> — partial <a>succ</a> <tt>STAN-0010</tt>.
stan0010 :: Inspection

-- | <a>Inspection</a> — partial <a>pred</a> <tt>STAN-0011</tt>.
stan0011 :: Inspection

-- | <a>Inspection</a> — partial <a>toEnum</a> <tt>STAN-0012</tt>.
stan0012 :: Inspection

-- | <a>Inspection</a> — partial <a>maximum</a> <tt>STAN-0013</tt>.
stan0013 :: Inspection

-- | <a>Inspection</a> — partial <a>minimum</a> <tt>STAN-0014</tt>.
stan0014 :: Inspection

-- | <a>Inspection</a> — partial <a>maximumBy</a> <tt>STAN-0015</tt>.
stan0015 :: Inspection

-- | <a>Inspection</a> — partial <a>minimumBy</a> <tt>STAN-0016</tt>.
stan0016 :: Inspection

-- | <a>Inspection</a> — partial <a>foldl1</a> <tt>STAN-0017</tt>.
stan0017 :: Inspection

-- | <a>Inspection</a> — partial 'Data.Foldable.foldl1''
--   <tt>STAN-0018</tt>.
stan0018 :: Inspection

-- | <a>Inspection</a> — partial <a>foldr1</a> <tt>STAN-0019</tt>.
stan0019 :: Inspection

-- | <a>Inspection</a> — partial <a>fromList</a> <tt>STAN-0020</tt>.
stan0020 :: Inspection

-- | <a>Inspection</a> — partial <a>fromInteger</a> <tt>STAN-0021</tt>.
stan0021 :: Inspection

-- | All partial <a>Inspection</a>s.
partialInspectionsMap :: InspectionsMap


-- | Contains all <a>Inspection</a>s for functions that hang on infinite
--   lists.
--   
--   The <b>infinite</b> inspections are in ranges:
--   
--   <ul>
--   <li><pre>STAN-0101 .. STAN-0200</pre></li>
--   </ul>
module Stan.Inspection.Infinite

-- | <a>Inspection</a> for <a>stan0101</a> — infinite <a>reverse</a>
--   <tt>STAN-0101</tt>.
stan0101 :: Inspection

-- | <a>Inspection</a> for <a>stan0102</a> — infinite <a>isSuffixOf</a>
--   <tt>STAN-0102</tt>.
stan0102 :: Inspection

-- | <a>Inspection</a> for <a>stan0103</a> — infinite <a>length</a> |
--   <a>length</a> <tt>STAN-0103</tt>.
stan0103 :: Inspection

-- | <a>Inspection</a> for <a>stan0104</a> — infinite <a>genericLength</a>
--   <tt>STAN-0104</tt>.
stan0104 :: Inspection

-- | <a>Inspection</a> for <a>stan0105</a> — infinite <a>sum</a>
--   <tt>STAN-0105</tt>.
stan0105 :: Inspection

-- | <a>Inspection</a> for <a>stan0106</a> — infinite <a>product</a>
--   <tt>STAN-0106</tt>.
stan0106 :: Inspection

-- | All infinite <a>Inspection</a>s map from <a>Id</a>s.
infiniteInspectionsMap :: InspectionsMap


-- | Contains all <a>Inspection</a>s for known anti-patterns.
--   
--   The <b>anti-pattern</b> inspections are in ranges:
--   
--   <ul>
--   <li><pre>STAN-0201 .. STAN-0300</pre></li>
--   </ul>
module Stan.Inspection.AntiPattern

-- | <a>Inspection</a> — <tt>[0 .. length xs]</tt> <tt>STAN-0201</tt>.
stan0201 :: Inspection

-- | <a>Inspection</a> — <tt>foldl</tt> <tt>STAN-0202</tt>.
stan0202 :: Inspection

-- | <a>Inspection</a> — <a>pack</a> <tt>STAN-0203</tt>.
stan0203 :: Inspection

-- | <a>Inspection</a> — slow <a>size</a> and <a>length</a>
--   <tt>STAN-0204</tt>.
stan0204 :: Inspection

-- | <a>Inspection</a> — slow <a>size</a> <tt>STAN-0205</tt>.
stan0205 :: Inspection

-- | <a>Inspection</a> — missing strictness declaration <tt>STAN-0206</tt>.
stan0206 :: Inspection

-- | <a>Inspection</a> — <a>Foldable</a> methods on possibly error-prone
--   structures <tt>STAN-0207</tt>.
stan0207 :: Inspection

-- | <a>Inspection</a> — slow <a>length</a> for <a>Text</a>
--   <tt>STAN-0208</tt>.
stan0208 :: Inspection

-- | <a>Inspection</a> — slow <tt>nub</tt> for lists <tt>STAN-0209</tt>.
stan0209 :: Inspection

-- | <a>Inspection</a> — slow <a>for_</a> and <a>forM_</a> for ranges
--   <tt>STAN-0210</tt>.
stan0210 :: Inspection

-- | <a>Inspection</a> — <tt><a>/</a></tt> on URLs <tt>STAN-0211</tt>.
stan0211 :: Inspection

-- | <a>Inspection</a> — usage of <tt>unsafe*</tt> functions
--   <tt>STAN-0212</tt>.
stan0212 :: Inspection

-- | <a>Inspection</a> — Pattent matching on <tt>_</tt> for sum types —
--   <tt>STAN-0213</tt>.
stan0213 :: Inspection

-- | <a>Inspection</a> — use <a>compare</a> <tt>STAN-0214</tt>.
stan0214 :: Inspection

-- | <a>Inspection</a> — Slashes in paths <tt>STAN-0215</tt>.
stan0215 :: Inspection

-- | All anti-pattern <a>Inspection</a>s map from <a>Id</a>s.
antiPatternInspectionsMap :: InspectionsMap


-- | Contains lists of all <a>Inspection</a>s and <a>Inspection</a>
--   <a>Id</a>s provided by <tt>Stan</tt>.
module Stan.Inspection.All

-- | All <a>Inspection</a>s map from <a>Id</a>s.
inspectionsMap :: InspectionsMap

-- | List of all inspections.
inspections :: [Inspection]

-- | Set of all inspection <a>Id</a>s.
inspectionsIds :: HashSet (Id Inspection)

-- | Look up <a>Inspection</a> by the given inspection <a>Id</a>.
lookupInspectionById :: Id Inspection -> Maybe Inspection

-- | Get the <a>Inspection</a> by the given known inspection <a>Id</a>.
getInspectionById :: Id Inspection -> Inspection


-- | <b>Observation</b> — a vulnerability found in the target project by
--   <tt>Stan</tt>.
module Stan.Observation

-- | Data type to represent discovered by Stan vulnerabilities.
data Observation
Observation :: !Id Observation -> !Id Inspection -> !RealSrcSpan -> !FilePath -> !ModuleName -> !ByteString -> Observation
[observationId] :: Observation -> !Id Observation
[observationInspectionId] :: Observation -> !Id Inspection
[observationLoc] :: Observation -> !RealSrcSpan
[observationFile] :: Observation -> !FilePath
[observationModuleName] :: Observation -> !ModuleName
[observationFileContent] :: Observation -> !ByteString

-- | Type alias for the sized list of <a>Observation</a>s.
type Observations = Slist Observation

-- | Smart constructor for <a>Observation</a>s from <a>HieFile</a>s.
mkObservation :: Id Inspection -> HieFile -> RealSrcSpan -> Observation

-- | Create a stable <a>Observation</a> <a>Id</a> in a such way that:
--   
--   <ol>
--   <li><a>Id</a> doesn't depend on other inspections in this file.</li>
--   <li><a>Id</a> uniquely identifies <a>Observation</a> location.</li>
--   <li><a>Id</a>s are guaranteed to be the same if the module content
--   didn't change between different <tt>stan</tt> runs.</li>
--   </ol>
--   
--   The <a>Observation</a> <a>Id</a> should look like this:
--   
--   <pre>
--   OBS-STAN-XXXX-<a>module-name-hash</a>-10:42
--   </pre>
mkObservationId :: Id Inspection -> ModuleName -> RealSrcSpan -> Id Observation
ignoredObservations :: [Id Observation] -> Observations -> ([Id Observation], [Id Observation])

-- | Show <a>Observation</a> in a human-friendly format.
prettyShowObservation :: ReportSettings -> Observation -> Text
prettyShowIgnoredObservations :: [Id Observation] -> Observations -> Text
prettyObservationSource :: Bool -> Observation -> [Text]
instance GHC.Classes.Eq Stan.Observation.Observation
instance GHC.Show.Show Stan.Observation.Observation


-- | File (or module) specific information.
module Stan.FileInfo
type FileMap = Map FilePath FileInfo

-- | File specific information.
data FileInfo
FileInfo :: !FilePath -> !ModuleName -> !Int -> !Either ExtensionsError ParsedExtensions -> !Either ExtensionsError ParsedExtensions -> !ExtensionsResult -> !Observations -> FileInfo
[fileInfoPath] :: FileInfo -> !FilePath
[fileInfoModuleName] :: FileInfo -> !ModuleName
[fileInfoLoc] :: FileInfo -> !Int
[fileInfoCabalExtensions] :: FileInfo -> !Either ExtensionsError ParsedExtensions
[fileInfoExtensions] :: FileInfo -> !Either ExtensionsError ParsedExtensions
[fileInfoMergedExtensions] :: FileInfo -> !ExtensionsResult
[fileInfoObservations] :: FileInfo -> !Observations

-- | Return the list of pretty-printed extensions.
extensionsToText :: Either ExtensionsError ParsedExtensions -> [Text]

-- | Check whether the given extension is disabled
isExtensionDisabled :: Extension -> ExtensionsResult -> Bool
instance GHC.Classes.Eq Stan.FileInfo.FileInfo
instance GHC.Show.Show Stan.FileInfo.FileInfo


-- | Analysing functions by <a>InspectionAnalysis</a> for the corresponding
--   <a>Inspection</a>.
module Stan.Analysis.Analyser

-- | Create analysing function for <a>Inspection</a> by pattern-matching
--   over <a>InspectionAnalysis</a>.
analysisByInspection :: ExtensionsResult -> Inspection -> HieFile -> Observations


-- | Static analysis of all HIE files.
module Stan.Analysis

-- | This data type stores all information collected during static
--   analysis.
data Analysis
Analysis :: !Int -> !Int -> !(Set OnOffExtension, Set SafeHaskellExtension) -> !HashSet (Id Inspection) -> !Observations -> !Observations -> !FileMap -> Analysis
[analysisModulesNum] :: Analysis -> !Int
[analysisLinesOfCode] :: Analysis -> !Int
[analysisUsedExtensions] :: Analysis -> !(Set OnOffExtension, Set SafeHaskellExtension)
[analysisInspections] :: Analysis -> !HashSet (Id Inspection)
[analysisObservations] :: Analysis -> !Observations
[analysisIgnoredObservations] :: Analysis -> !Observations
[analysisFileMap] :: Analysis -> !FileMap

-- | Perform static analysis of given <a>HieFile</a>.
runAnalysis :: Map FilePath (Either ExtensionsError ParsedExtensions) -> HashMap FilePath (HashSet (Id Inspection)) -> [Id Observation] -> [HieFile] -> Analysis
instance GHC.Show.Show Stan.Analysis.Analysis


-- | Pretty printing of Stan's analysis.
module Stan.Analysis.Pretty

-- | Shows analysed output of Stan work. This functions groups
--   <a>Observation</a>s by <a>FilePath</a> they are found in.
prettyShowAnalysis :: Analysis -> ReportSettings -> Text
data AnalysisNumbers
AnalysisNumbers :: !Int -> !Int -> !Int -> !Int -> !Int -> !Int -> !Int -> !Double -> AnalysisNumbers
[anModules] :: AnalysisNumbers -> !Int
[anLoc] :: AnalysisNumbers -> !Int
[anExts] :: AnalysisNumbers -> !Int
[anSafeExts] :: AnalysisNumbers -> !Int
[anIns] :: AnalysisNumbers -> !Int
[anFoundObs] :: AnalysisNumbers -> !Int
[anIgnoredObs] :: AnalysisNumbers -> !Int
[anHealth] :: AnalysisNumbers -> !Double

-- | Enum to describe project health depending on the value of
--   <a>anHealth</a>.
data ProjectHealth
Unhealthy :: ProjectHealth
LowHealth :: ProjectHealth
MediumHealth :: ProjectHealth
Healthy :: ProjectHealth
analysisToNumbers :: Analysis -> AnalysisNumbers

-- | Show project health as pretty text with 2 digits after dot.
prettyHealth :: Double -> Text

-- | Calculate <a>ProjectHealth</a>.
toProjectHealth :: Double -> ProjectHealth


-- | <tt>stan</tt> runtime configuration that allows customizing the set of
--   inspections to check the code against.
module Stan.Config

-- | Main configuration type for the following purposes:
--   
--   <ul>
--   <li>Filtering inspections (including or ignoring) per scope (file,
--   directory, all)</li>
--   </ul>
data ConfigP (p :: Phase Text)
ConfigP :: !p ::- [Check] -> !p ::- [Scope] -> !p ::- [Id Observation] -> ConfigP (p :: Phase Text)
[configChecks] :: ConfigP (p :: Phase Text) -> !p ::- [Check]
[configRemoved] :: ConfigP (p :: Phase Text) -> !p ::- [Scope]
[configIgnored] :: ConfigP (p :: Phase Text) -> !p ::- [Id Observation]
type Config = ConfigP 'Final
type PartialConfig = ConfigP 'Partial

-- | Rule to control the set of inspections per scope.
data Check
Check :: !CheckType -> !CheckFilter -> !Scope -> Check
[checkType] :: Check -> !CheckType
[checkFilter] :: Check -> !CheckFilter
[checkScope] :: Check -> !Scope

-- | Type of <a>Check</a>: <a>Include</a> or <a>Exclude</a>
--   <a>Inspection</a>s.
data CheckType
Include :: CheckType
Exclude :: CheckType

-- | Criterion for inspections filtering.
data CheckFilter
CheckInspection :: !Id Inspection -> CheckFilter
CheckSeverity :: !Severity -> CheckFilter
CheckCategory :: !Category -> CheckFilter
CheckAll :: CheckFilter

-- | Where to apply the rule for controlling inspection set.
data Scope
ScopeFile :: !FilePath -> Scope
ScopeDirectory :: !FilePath -> Scope
ScopeAll :: Scope
defaultConfig :: PartialConfig
mkDefaultChecks :: [FilePath] -> HashMap FilePath (HashSet (Id Inspection))
finaliseConfig :: PartialConfig -> Trial Text Config

-- | Convert TOML configuration to the equivalent CLI command that can be
--   copy-pasted to get the same results as using the TOML config.
--   
--   <pre>
--     ⓘ Reading Configurations from /home/vrom911/Kowainik/stan/.stan.toml ...
--   stan check --exclude --directory=test/ \
--        check --include \
--        check --exclude --inspectionId=STAN-0002 \
--        check --exclude --inspectionId=STAN-0001 --file=src/MyFile.hs
--        remove --file=src/Secret.hs
--        ignore --id="STAN0001-asdfgh42:42"
--   </pre>
configToCliCommand :: Config -> Text

-- | Apply configuration to the given list of files to get the set of
--   inspections for each file.
--   
--   The algorithm:
--   
--   <ol>
--   <li>Remove all files specified by the <tt>remove</tt> option.</li>
--   <li>Run <a>applyChecks</a> on the remaining files.</li>
--   </ol>
applyConfig :: [FilePath] -> Config -> HashMap FilePath (HashSet (Id Inspection))

-- | Convert the list of <a>Check</a>s from <a>Config</a> to data structure
--   that allows filtering of <a>Inspection</a>s for given files.
applyChecks :: [FilePath] -> [Check] -> HashMap FilePath (HashSet (Id Inspection))

-- | Modify existing <a>Check</a>s for each file using the given list of
--   <a>Check</a>s.
applyChecksFor :: HashMap FilePath (HashSet (Id Inspection)) -> [Check] -> HashMap FilePath (HashSet (Id Inspection))
instance GHC.Classes.Eq Stan.Config.Check
instance GHC.Show.Show Stan.Config.Check
instance GHC.Classes.Eq Stan.Config.Scope
instance GHC.Show.Show Stan.Config.Scope
instance GHC.Classes.Eq Stan.Config.CheckFilter
instance GHC.Show.Show Stan.Config.CheckFilter
instance GHC.Enum.Bounded Stan.Config.CheckType
instance GHC.Enum.Enum Stan.Config.CheckType
instance GHC.Classes.Eq Stan.Config.CheckType
instance GHC.Show.Show Stan.Config.CheckType
instance (GHC.Show.Show (p Trial.::- [Stan.Config.Check]), GHC.Show.Show (p Trial.::- [Stan.Config.Scope]), GHC.Show.Show (p Trial.::- [Stan.Core.Id.Id Stan.Observation.Observation])) => GHC.Show.Show (Stan.Config.ConfigP p)
instance (GHC.Classes.Eq (p Trial.::- [Stan.Config.Check]), GHC.Classes.Eq (p Trial.::- [Stan.Config.Scope]), GHC.Classes.Eq (p Trial.::- [Stan.Core.Id.Id Stan.Observation.Observation])) => GHC.Classes.Eq (Stan.Config.ConfigP p)
instance GHC.Base.Semigroup Stan.Config.PartialConfig


-- | <tt>stan</tt> configuration pretty printing helper functions.
module Stan.Config.Pretty
data ConfigAction
RemoveAction :: ConfigAction
IncludeAction :: ConfigAction
ExcludeAction :: ConfigAction
IgnoreAction :: ConfigAction
prettyConfigAction :: ConfigAction -> Text
configActionClass :: ConfigAction -> Text
configActionColour :: ConfigAction -> Text
prettyConfigCli :: Config -> Text
configToTriples :: Config -> [(ConfigAction, Text, Text)]
instance GHC.Classes.Eq Stan.Config.Pretty.ConfigAction
instance GHC.Show.Show Stan.Config.Pretty.ConfigAction


-- | CLI commands and options for <tt>stan</tt>.
module Stan.Cli

-- | Commands used in Stan CLI.
data StanCommand

-- | Just <tt>stan</tt> with its options.
Stan :: !StanArgs -> StanCommand

-- | <tt>stan inspection</tt>.
StanInspection :: !InspectionArgs -> StanCommand

-- | <pre>
--   stan toml-to-cli
--   </pre>
StanTomlToCli :: !TomlToCliArgs -> StanCommand

-- | <pre>
--   stan cli-to-toml
--   </pre>
StanCliToToml :: !CliToTomlArgs -> StanCommand

-- | <pre>
--   stan inspections-to-md
--   </pre>
StanInspectionsToMd :: StanCommand

-- | Options used for the main <tt>stan</tt> command.
data StanArgs
StanArgs :: !FilePath -> ![FilePath] -> !ReportSettings -> !Bool -> !TaggedTrial Text Bool -> !Maybe FilePath -> !PartialConfig -> StanArgs

-- | Directory with HIE files
[stanArgsHiedir] :: StanArgs -> !FilePath

-- | Path to <tt>.cabal</tt> files.
[stanArgsCabalFilePath] :: StanArgs -> ![FilePath]

-- | Settings for report
[stanArgsReportSettings] :: StanArgs -> !ReportSettings

-- | Create <tt>HTML</tt> report?
[stanArgsReport] :: StanArgs -> !Bool

-- | Use default <tt>.stan.toml</tt> file
[stanArgsUseDefaultConfigFile] :: StanArgs -> !TaggedTrial Text Bool

-- | Path to a custom configurations file.
[stanArgsConfigFile] :: StanArgs -> !Maybe FilePath
[stanArgsConfig] :: StanArgs -> !PartialConfig

-- | Options used for the <tt>stan inspection</tt> command.
newtype InspectionArgs
InspectionArgs :: Maybe (Id Inspection) -> InspectionArgs
[inspectionArgsId] :: InspectionArgs -> Maybe (Id Inspection)

-- | Options used for the <tt>stan toml-to-cli</tt> command.
newtype TomlToCliArgs
TomlToCliArgs :: Maybe FilePath -> TomlToCliArgs
[tomlToCliArgsFilePath] :: TomlToCliArgs -> Maybe FilePath

-- | Options used for the <tt>stan cli-to-toml</tt> command.
data CliToTomlArgs
CliToTomlArgs :: !Maybe FilePath -> !PartialConfig -> CliToTomlArgs
[cliToTomlArgsFilePath] :: CliToTomlArgs -> !Maybe FilePath
[cliToTomlArgsConfig] :: CliToTomlArgs -> !PartialConfig

-- | Run main parser of the <tt>stan</tt> command line tool.
runStanCli :: IO StanCommand

-- | To turn on some special options.
stanParserPrefs :: ParserPrefs
stanCliParser :: ParserInfo StanCommand


-- | Static analysis summary.
module Stan.Analysis.Summary

-- | Short info about analysis.
data Summary
Summary :: !Id Inspection -> !Category -> !ModuleName -> !Severity -> Summary

-- | The most popular <a>Inspection</a>
[summaryInspectionId] :: Summary -> !Id Inspection

-- | The most popular <a>Category</a>
[summaryCategory] :: Summary -> !Category

-- | Module with the biggest number of observations
[summaryModule] :: Summary -> !ModuleName

-- | The highest <a>Severity</a>
[summarySeverity] :: Summary -> !Severity

-- | Assemble <a>Summary</a> after analysis. Returns <a>Nothing</a> when
--   there's no <tt>Observations</tt>. Otherwise, there's at least one
--   observation, which means that we can find the most popular
--   <a>Inspection</a>, <a>Category</a> and the highest <a>Severity</a>.
createSummary :: Analysis -> Maybe Summary


-- | HTML to be generated in the report.
module Stan.Report.Html
stanHtml :: Analysis -> Config -> [Text] -> StanEnv -> ProjectInfo -> Html


-- | Report and report settings types.
module Stan.Report
generateReport :: Analysis -> Config -> [Text] -> StanEnv -> ProjectInfo -> IO ()


-- | <tt>tomland</tt> library integration. <a>TomlCodec</a>s for the
--   <tt>Config</tt> data type.
module Stan.Toml
getTomlConfig :: Bool -> Maybe FilePath -> IO PartialConfig
configCodec :: TomlCodec PartialConfig

-- | Based on the incoming settings returns the TOML configuration files
--   that were used to get the final config.
usedTomlFiles :: Bool -> Maybe FilePath -> IO [FilePath]


-- | Main running module.
module Stan
run :: IO ()

-- | From a given path to cabal files and <a>HieFile</a>s create the map
--   from modules (that are in .cabal file) to the resulting parsed
--   extensions for each.
createCabalExtensionsMap :: [FilePath] -> [HieFile] -> IO (Map FilePath (Either ExtensionsError ParsedExtensions))