#D      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                            !!!!!!!!!!!!""""" "!"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7#8#9#:#;#<#=#>$?%@&A&B&C')(None"#%,/17;HMPX_kBDEFGHIJK(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k'/ ustanA type of the inspection.xstanShow u in a human-friendly format.ystanList category of Stan inspections.zstanPartial category of Stan inspections.{stanInfinite category of Stan inspections.|stan AntiPattern category of Stan inspections.}stan SpaceLeak category of Stan inspections.~stanSyntax/ category of Stan inspections. Usually used in ) inspections.stanUnsafe category of Stan inspections.stanThe list of all available Stan us. uvwxyz{|}~ uvwx|{yz}~(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,./17;HMPUVX_k.stanJA type alias for the situations when we don't care about the parameter of , but don't want to deal with type variables.stanqA wrapper around the textual value to safely represent IDs for different structures by using a phantom parameter.stanUnsafe cast of ?. Implementation uses smart trick to enforce usage always with TypeApplications.(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k9stanUChecks that two lists have the same length and that a given binary predicate returns L( on each corresponding pair of elements.checkWith (==) [] []TruecheckWith (==) [1, 2] [1, 2]TruecheckWith (==) [1, 2] [2, 1]FalsecheckWith (==) [1, 2] [1]Falsestan@Returns list all element pairs without the following properties:No element with itself: (x, x) Only one of (x, y) and (y, x) will be in the resultIn 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. foo [1..3][(1, 2), (1, 3), (2, 3)](c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k;U*(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_gk=(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k>7FEDCBJIHGKA@?L>=PMONSRQXWVUTYZ[\]^_`dcbhgfeijklnmqoprst7qr`o_pt[]Z\Y^nijlkmPMONSRQsXWVUTKA@?JIHGFEDCBL>=dcbhgfe(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kClstan#Wrapper around Haskell module name.stanConvert +, to .stanExtract  from +-.(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kE%>  "! '&%$#(,+*)76543210/.-<;:98a>76543210/.-"!  <;:98(,+*)'&%$# a(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kPstanGets the list of .cabal* file paths that were used in the project.stan%From a given path to cabal files and  ds create the map from modules (that are in .cabal file) to the resulting parsed extensions for each.MstanRecursively find all .cabalM files in the current directory and its subdirectories. It returns maximum 1 .cabal file from each directory.NstanFind a .cabalC file in the given directory. TODO: better error handling in stan.stan.cabal files (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kWstan*Data from different environment resources:Environment variablesUsed TOML configuration filesCommand Line argumentsstan Contains all stan System informationstanstan version information.stanCurrent stan version information.stanColourful pretty  representation used in the CLI.stanAll system info for the project (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kh stan%Meta information about function/type.stan Pretty show  in the following format: package/module/name.stan Check if  is identical to t.stanCheck whether HIE ( with details is a given .stanCheck if the given "' node is identifier equal to the given .stanCreate  for a function from the base package and a given  . module.stanCreate  for a function from the base package and the GHC.List module.stanCreate  for a function from the base package and the  Data.OldList module.stanCreate  for a function from the base package and the  Data.Foldable module.stanCreate  for a function from the unordered-containers package and a given  module.stanCreate  for a function from the text package and a given  module.stanCreate  for a function from the ghc-prim package and a given  module.stan for primitive types.stanName meta infostanHIE identifier8888 (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kjy (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_krXstanCommon interface for Oq-like parts of patterns. Allows to write composable and reusable complex pattern definitions from smaller pieces.1Laws (in terms of matching functions that return O):  "a L   "a P   x "a x   "a L   x "a x   "a xstan(Anything. Matching should always return L.stan Negation. Inverses the argument.stanOr-pattern. Choice.stanAnd-pattern. Both.23 (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kstan.Query pattern used to search types in HIE AST.stanArgument, type or constructor: a  !PatternName (NameMeta ... "a") []  [a]  *PatternName (NameMeta ... "[]") [aPattern]  Either Int String  ?PatternName (NameMeta ... "Either") [intPattern, stringPattern] stanFunction pattern.stan Type wildcard, matches anything.stan5Choice between patterns. Should match either of them.stan-Union of patterns. Should match both of them.stanANegation of pattern. Should match everything except this pattern.stanShort operator alias for  PatternFun.stanShort operator alias for .stan for list [a] or Q.stan for R.stan for [a] -> _ or  String -> _.stan for S.stan for T.stan for Q.stan for U.stanList of types for  STAN-0207.Vstan for WXstan for YZstan for pair (,).stanType patterns for the [= typeclass methods. Represented as a non-empty list of pairs: Method name1Function from type to pattern (where things like W, Y should be)45(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k1  stanQuery 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. stanInteger constant in code. stan3Name of a specific function, variable or data type. stanVariable name. stanSet of context info (pairs of tags) | AST node with tags for current node and children patterns. This pattern should match the node exactly.stan5Choice between patterns. Should match either of them.stan-Union of patterns. Should match both of them.stanANegation of pattern. Should match everything except this pattern.stanFunction that creates  ( from the given non-empty list of pairs  and .If the list contains only one  then it is simple   . Else it is  of all such  s.stanLike  but doesn't care about types.stanapp f x' is a pattern for function application f x.stan opApp x op y' is a pattern for operator application x op y.stan range a b is a pattern for [a .. b]stan is a pattern for case' expression (not considering branches).stan is a pattern for  case EXP of' expression (not considering branches).stan1Pattern to represent one pattern matching branch.stan Pattern for _ in pattern matching.Note: presents on GHC >=8.10 only.stan)Pattern for literals in pattern matching.Note: presents on GHC >=8.10 only.stan4Pattern to represent one pattern matching branch on _.stan>Pattern to represent right side of the pattern matching, e.g. -> "foo".stan-Pattern for the top-level fixity declaration: infixr 7 ***, +++, ???  stan4Pattern for the function type signature declaration: foo :: Some -> Type !stan$Pattern for the function definition: foo x y = ... "standata or newtype declaration.#stanoConstructor of a plain data type or newtype. Children of node that matches this pattern are constructor fields.$stan*Lazy data type field. Comes in two shapes: Record field, like:  foo :: Text Simple type: Int\stanGPattern for any occurrence of a plain type. Covers the following cases:Simple type: Int, Bool, a.Higher-kinded type: Maybe Int, Either String aType in parenthesis: (Int)Tuples: (Int, Bool)List type: [Int]Function type: Int -> Bool]stan8Pattern for the field without the explicit bang pattern: someField :: Int %stanPattern for tuples:,Type signatures: foo :: (Int, Int, Int, Int) Literals: (True, 0, [], Nothing)&stanPattern for a single guard branch:  | x < y = ... 'stan:Pattern for the right-hand-side. Usually an equality sign.  foo = baz (stan)Annotations for constants: 0, "foo", etc.stan#Set of context info (pairs of tags)stan0Node children | AST wildcard, matches anything.&      !"#$%&'(&     #"!&$'% ((c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k.stanReturns contents of all .hie files recursively in the given hie directory./stan9Get the number of lines of code in the file by analising  .0stan.Take sub-bytestring according to a given span.1TODO: currently works only with single-line spans1stanICompare two AST nodes on equality. This is a more relaxed version of the ^ instance for " 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  % because constants are not stored in "B and to compare constants we need to compare parts of source code../01./10(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k2stan?Matching function that searches the array of types recursively.2stanArray of all types in HIE filestanOur search querystan$Index of the current expression typestanIf matched type is found22(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_ku3stanEMatching function that matches current AST node with a given pattern.3stanHIE filestanCurrent AST node to matchstanPattern to match againststanL if pattern matches AST node33(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMOPX_k44(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k5stan@Boolean for showing/hiding solution information of observations.;stanSettings for produced report.@stanIs the toggle option set to 6? 56789:;<=>?@ ;<=>89:?567@(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k Cstan!Severity level of the inspection. Severity 5 Example  D  Missing infix, or type signature in where  E  Usage of ./, .0  F Some common user errors: [0 .. length xs]  G  Partial functions, like 12  H  Usage of _ in code Dstan$Code style issues. Usually harmless.Estan<Serious defects that could cause slowness and space leaking.FstanHuman errors in code.Gstan(Potential runtime errors on some inputs.HstanDangerous behaviour.IstanDescription of each C level.Jstan%Get the colour of the severity level.KstanShow C in a human-friendly format. CHDGEFIJK CHDGEFIJK(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kE Rstan0Data type that represents all possible types of stan inspections in a uniformed way.SstanIFind the specific part of the Haskell AST (including specific functions).Tstan$Find all operators without matching  infix[r|l]Ustan&Check if the data type has lazy fieldsVstanUsage of tuples with size >= 4WstanPattern matching on _ for sum types.Xstan,Replace multiple comparison operations with `YstanType alias for the a$ that contains pairs of inspections s and corresponding Zs.Zstan:Data type that represents a check/test, or how we call it  inspection# that is provided by the Stan tool.hstanSort Z by istanShow Z in a human-friendly format.jstanShow the short view of a given Z.kstansCreate 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.RTSUVWXYZ[\]^_`abcdefghijkZ[\]^_`abecdfgRTSUVWXYhijk(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kpstanAll anti-pattern Z s map from s.qstanZ  missing fixity declaration  STAN-0301.rstanZ  to big tuples  STAN-0302.pqrqrp(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k]sstan All partial Zs.bstan,Smart constructor to create generic partial Z with a given Pattern.cstan,Smart constructor to create generic partial Z with PatternAnything.dstan$Smart constructor to create partial Z$ for functions that work with lists.estan$Smart constructor to create partial Z/ for functions that work with enumerable types.tstanZ  partial 12  STAN-0001.ustanZ  partial 13  STAN-0002.vstanZ  partial 14  STAN-0003.wstanZ  partial 15  STAN-0004.xstanZ  partial 16  STAN-0005.ystanZ  partial 17  STAN-0006.zstanZ  partial 89  STAN-0007.{stanZ  partial :;  STAN-0008.|stanZ  partial <=  STAN-0009.}stanZ  partial >?  STAN-0010.~stanZ  partial >@  STAN-0011.stanZ  partial >A  STAN-0012.stanZ  partial .B  STAN-0013.stanZ  partial .C  STAN-0014.stanZ  partial .D  STAN-0015.stanZ  partial .E  STAN-0016.stanZ  partial .F  STAN-0017.stanZ#  partial 'Data.Foldable.foldl1''  STAN-0018.stanZ  partial .G  STAN-0019.stanZ  partial HI  STAN-0020.stanZ  partial JK  STAN-0021.bstan Type namecstan Type namestuvwxyz{|}~tuvwxyz{|}~s(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k ,stan All infinite Z s map from s.fstan%Smart constructor to create infinite Z.stanZ for   infinite g  STAN-0101.stanZ for   infinite 8L  STAN-0102.stanZ for   infinite .M | 8M  STAN-0103.stanZ for   infinite 8N  STAN-0104.stanZ for   infinite ./  STAN-0105.stanZ for   infinite .O  STAN-0106.(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kstanAll anti-pattern Z s map from s.hstan)Smart constructor to create anti-pattern Z.stanZ  [0 .. length xs]  STAN-0201.stanZ  foldl  STAN-0202.stanZ  PQ  STAN-0203.stanZ  slow RS and i  STAN-0204.stanZ  slow RS  STAN-0205.stanZ"  missing strictness declaration  STAN-0206.stanZ  [, methods on possibly error-prone structures  STAN-0207.stanZ  slow i for TU  STAN-0208.stanZ  slow nub for lists  STAN-0209.stanZ  slow j and k for ranges  STAN-0210.stanZ   / on URLs  STAN-0211.stanZ  usage of unsafe* functions  STAN-0212.stanZ  Pattent matching on _ for sum types   STAN-0213.stanZ  use `  STAN-0214.stanZ  Slashes in paths  STAN-0215.(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kstanAll Z s map from s.stanList of all inspections.stanSet of all inspection s.stanLook up Z by the given inspection .stanGet the Z by the given known inspection .(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k-stan!Type alias for the sized list of s.stan:Data type to represent discovered by Stan vulnerabilities.stanSmart constructor for s from  s.stanShow  in a human-friendly format.lstanaCheckes the predicate on colourfulness and returns an empty text when the colouroing is disabled.stanCreate a stable   in a such way that: 2 doesn't depend on other inspections in this file. uniquely identifies  location.Vs are guaranteed to be the same if the module content didn't change between different stan runs.The   should look like this: OBS-STAN-XXXX- module-name-hash-10:42 mstan-Hash module name to a short string of length 6%. Hashing algorithm is the following: First, run SHA-1.Then, encode with base64.Last, take first 6 characters.stanCorresponding Zs .stan Position.stan Use colouringstanIgnored ^ Unknown(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k1:stanFile specific information.stan-Return the list of pretty-printed extensions.stan-Check whether the given extension is disabled  (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kRnstan/Either top-level operator or fixity declarationostan0Operator name with its position to display laterstanCreate analysing function for Z by pattern-matching over R.pstan:Check for occurrences of the specified function given via .qstan9Check for big tuples (size >= 4) in the following places:,Type signatures: foo :: (Int, Int, Int, Int) Literals: (True, 0, [], Nothing)rstan?Find usages of multiple comparison operators and suggest using `). Currently, handles the following cases:GuardscThe algorithm is to find all guards, filter them by usage of comparison operators and find matches.sstan?Check for occurrences lazy fields in all constructors. Ignores newtypeGs. Currently HIE Ast doesn't have information whether the data type is newtypet or not. So the algorithm ignores all data types with a single constructor and single field inside that constructor.tstan-Check for occurrences of pattern matching on _! for sum types (except literals).ustanMAnalyse HIE AST to find all operators which lack explicit fixity declaration.The algorithm is the following: 6Traverse AST and discover all top-level operators and infix declarations in a single pass.9Compare two resulting sets to find out operators without infix declaration.vstan<Partition a foldable of operator declarations into two maps: Fixity declarations (mapped to ()).;Top-level operator names (mapped to their source positions.w$ is used to be able to use the nice merge function.xstan2Analyses the whole AST starting from the very top.ystan6Recursively match AST nodes starting from a given AST.zstanLike {' but returns source spans of AST nodes.{stan-Create a non-recursive matching function for  : that returns sized list of nodes that match this pattern.If the pattern matches ! , return itOtherwise return empty listxstan^Function to match AST node to some arbitrary type and return a sized list of matched elementsystan^Function to match AST node to some arbitrary type and return a sized list of matched elements(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k]sstanGThis data type stores all information collected during static analysis.|stanIncrease the total loc (0) by the given number of analised lines of code.}stan Add set of Z s to the existing set.~stan Add list of 's to the beginning of the existing liststan Add list of 's to the beginning of the existing liststan#Collect all unique used extensions.stanUpdate  for the given .stan!Perform static analysis of given  .stan#List of to-be-ignored Observations.stan#List of to-be-ignored Observations.stan#List of to-be-ignored Observations.  (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kc0stan:Enum to describe project health depending on the value of .stan:Shows analysed output of Stan work. This functions groups s by  they are found in.stan;Show project health as pretty text with 2 digits after dot.stan Calculate . (c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,./017;=>?HMPUVX_ek} stan7Where to apply the rule for controlling inspection set.stan$Criterion for inspections filtering.stan1Rule to control the set of inspections per scope.stanType of :  or  Zs.stan3Main configuration type for the following purposes:PFiltering inspections (including or ignoring) per scope (file, directory, all)stanConvert TOML configuration to the equivalent CLI command that can be copy-pasted to get the same results as using the TOML config. G $ 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" stan[Apply configuration to the given list of files to get the set of inspections for each file.The algorithm: "Remove all files specified by the remove option.Run  on the remaining files.stanConvert the list of s from , to data structure that allows filtering of Zs for given files.stanModify existing (s for each file using the given list of s.stanPaths to project filesstanStan runtime configurationstan*Resulting set of inspections for each filestanPaths to project filesstan List of rulesstan*Resulting set of inspections for each filestan(Initial set of inspections for each filestan List of rulesstan*Resulting set of inspections for each file!(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k  "(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/017;HMPX_kstanOptions used for the stan cli-to-toml command.stanOptions used for the stan toml-to-cli command."stanOptions used for the stan inspection command.%stanOptions used for the main stan command.'stanDirectory with HIE files(stanPath to .cabal files.)stanSettings for report*stanCreate HTML report?+stan Use default  .stan.toml file,stan%Path to a custom configurations file..stanCommands used in Stan CLI./stanJust stan with its options.0stanstan inspection.1stan stan toml-to-cli2stan stan cli-to-toml3stan stan inspections-to-md4stanRun main parser of the stan command line tool.5stan To turn on some special options.stan@Stan tool parser. It either uses the named commands or the main stan command.stanstan command parser.stanstan inspection command parser.stanJThe solution is shown by default and gets hidden when option is specified.stanThe G is shown juicy by default and gets shortened when option is specified.stan Parser of an ?. Receives a string to specify in Help what kind of ID is this.stanShow the version of the tool. !"#$%&'()*+,-./0123456./0123%&'()*+,-"#$ !456#(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k stanCount of each inspectionstanCount of each categorystan Count of observations per modulestanHighest severity7stanShort info about analysis.9stanThe most popular Z:stanThe most popular u;stan.Module with the biggest number of observations<stan The highest C=stan Assemble 7 after analysis. Returns  when there's no  Observations]. Otherwise, there's at least one observation, which means that we can find the most popular Z, u and the highest C.stanFast, strict maximum789:;<=789:;<=$(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k>>%(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_k?stan'Warnings during Trial config selectionsstanEnvironment informationstanProject related Information??&(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/017;HMPX_k$@stankBased on the incoming settings returns the TOML configuration files that were used to get the final config.stanHelper  for the hardcoded string "all".@ABAB@'(c) 2020 KowainikMPL-2.0Kowainik <xrom.xkov@gmail.com>None"#%,/17;HMPX_kCCVWXVWYVWZV[\V[[V]^V]_V]`V]aV]bV]cV]dV]dV]eV]fV]gV]hV]iV]jV]kV]lV]mV]nV]oV]pV]qV]qV]rV]sV]sV]tV]uV]vV]wV]xV]yV]zV]{V]|V]|V]}V]~V]V]V]V]V]V]V]V]V]V]V]V]V]V]V]V]V]V]V]VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV-V-VVVVVVVVVVVVVVV-V-V--V-,VV,,                                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)       !"#$%& ' ( ) * + , - . / 0 0 1 2 3 4 5 6 7 8 9 9 : ; < = > ? @ A B C D E F G H I J K L M N O P!Q!R!S!T!U!V!W!X!Y!Z![!\"]"]"^"_"`"`"a"b"b"c"d"d"e"f"g"h"i"j"k"l"'"m"n"o"p"q"r"s#t#t#u#v#w#x#y$z%{&|&}&~'((((((((U   .1.M.."""""""#####&stan-0.0.0.0-inplaceStan.Hie.CompatStan.Ghc.Compat Stan.Category Stan.Core.IdStan.Core.List Stan.EnvVarsStan.Core.ModuleName Stan.Cabal Stan.Info Stan.NameMetaStan.Hie.DebugStan.Pattern.EdslStan.Pattern.TypeStan.Pattern.AstStan.HieStan.Hie.MatchTypeStan.Hie.MatchAstStan.Report.CssStan.Report.Settings Stan.SeverityStan.InspectionStan.Inspection.StyleStan.Inspection.PartialStan.Inspection.InfiniteStan.Inspection.AntiPatternStan.Inspection.AllStan.Observation Stan.FileInfoStan.Analysis.Analyser Stan.AnalysisStan.Analysis.Pretty Stan.ConfigStan.Config.PrettyStan.CliStan.Analysis.SummaryStan.Report.Html Stan.Report Stan.TomlStan Paths_stanStyle Stan.ExampleGHC ModuleNameModule Data.FoldablesumfoldlGHC.Listheadtailinitlast!!cycle Data.OldList genericIndex Data.MaybefromJust Text.ReadreadGHC.EnumsuccpredtoEnummaximumminimum maximumBy minimumByfoldl1foldr1GHC.ExtsfromListGHC.Num fromInteger isSuffixOflength genericLengthproductData.ByteString.Char8packData.HashMap.StrictsizeDataTextghcHieBin readHieFilehie_file_result HieFileResult NameCache initNameCacheHieTypes hie_hs_src hie_exportshie_asts hie_types hie_module hie_hs_fileHieFile TypeIndex HCoercionTyHCastTyHLitTyHQualTyHFunTy HForAllTy HTyConAppHAppTyHTyVarTyHieType HieTypeFlatHieArgsgetAstsHieASTs nodeChildrennodeSpannodeInfoNodeHieASTnodeIdentifiersnodeTypenodeAnnotationsNodeInfo Identifier identInfo identTypeIdentifierDetailsRecField TyVarBindDecl ClassTyDecl PatternBindValBindTyDeclIEThing MatchBindUse ContextInfoExport ImportHidingImportAsImportIEType IfaceType IfaceStrTyLit IfaceNumTyLitifaceTyConInfoifaceTyConName IfaceTyConIfaceEqualityTyCon IfaceSumTyConIfaceTupleTyConIfaceNormalTyConIfaceTyConSortifaceTyConSortifaceTyConIsPromotedIfaceTyConInfo IfaceTyLitVarRequired SpecifiedInferredArgFlagAvailAvailTC AvailInfo FieldLabel flSelectorflIsOverloadedflLabelFieldLblNamenameStableString nameModuleisExternalName nameOccNameOccNameisSymOcc occNameStringmoduleStableStringmoduleNameString UniqSupplymkSplitUniqSupply BasicTypes IsPromoted NotPromoted PromotionFlagConstraintTuple UnboxedTuple BoxedTuple TupleSortSrcLoc srcSpanEndColsrcSpanStartColsrcSpanEndLinesrcSpanStartLine srcSpanFile RealSrcSpan moduleName moduleUnitId FastStringCategory unCategoryprettyShowCategorylistpartialinfinite antiPattern spaceLeaksyntaxunsafestanCategories$fShowCategory $fEqCategory$fHashableCategoryAnyIdIdunIdcastId$fShowId$fEqId$fOrdId $fHashableId checkWithnonRepeatingPairsEnvVarsenvVarsUseDefaultConfigFile getEnvVars envVarsToText unModuleNamefromGhcModuleName fromGhcModule$fShowModuleName$fEqModuleName$fHashableModuleName$fIsStringModuleNameusedCabalFilescreateCabalExtensionsMapmergeParsedExtensions ProjectInfopiName piCabalFilespiHieDir piFileNumberStanEnv seEnvVars seTomlFiles seCliArgs StanSystemssOsssArch ssCompilerssCompilerVersion StanVersion svVersion svGitRevision svCommitDate stanVersionprettyStanVersion stanSystem$fShowStanVersion$fEqStanVersion$fShowStanSystem$fEqStanSystem $fShowStanEnv $fEqStanEnv$fShowProjectInfo$fEqProjectInfoNameMetanameMetaPackagenameMetaModuleName nameMetaNameprettyShowNameMeta compareNameshieMatchNameMetahieFindIdentifier baseNameFrommkBaseListMetamkBaseOldListMetamkBaseFoldableMetaunorderedNameFrom textNameFromghcPrimNameFrom primTypeMeta$fShowNameMeta $fEqNameMeta debugHieFile $fShowName $fShowModule$fShowFieldLbl$fShowAvailInfo $fShowArgFlag$fShowTupleSort$fShowPromotionFlag$fShowIfaceTyLit$fShowIfaceTyConSort$fShowIfaceTyConInfo$fShowIfaceTyCon$fShowIdentifierDetails$fShowNodeInfo $fShowHieArgs $fShowHieASTs $fShowHieAST $fShowHieType $fShowHieFile PatternBool?neg|||&&& PatternTypePatternTypeNamePatternTypeFunPatternTypeAnything PatternTypeOrPatternTypeAndPatternTypeNeg|->|:: listPatternnonEmptyPatternlistFunPatternintegerPatternnaturalPattern charPattern stringPattern textPatternfoldableTypesPatternsfoldableMethodsPatterns$fPatternBoolPatternType$fShowPatternType$fEqPatternTypeLiteralExactNumExactStr PrefixStr ContainStr AnyLiteral PatternAstPatternAstConstantPatternAstNamePatternAstVarNamePatternAstNodePatternAstNodeExactPatternAstAnything PatternAstOr PatternAstAnd PatternAstNegnamesToPatternAstanyNamesToPatternAstappopApprange lambdaCasecase'patternMatchBranchwildPat literalPat patternMatch_patternMatchArrowfixitytypeSigfundataDecl constructor lazyFieldtuple guardBranchrhs literalAnns$fPatternBoolPatternAst $fShowLiteral $fEqLiteral$fShowPatternAst$fEqPatternAst readHieFilescountLinesOfCodesliceeqAsthieMatchPatternTypehieMatchPatternAststanCssToggleSolution HideSolution ShowSolution VerbosityVerbose NonVerboseReportSettingsreportSettingsVerbosityreportSettingsSolutionVerbosity isVerboseisHidden$fShowVerbosity$fShowToggleSolutionSeverity Performance PotentialBugWarningErrorseverityDescriptionseverityColourprettyShowSeverity$fShowSeverity$fReadSeverity $fEqSeverity $fOrdSeverity$fEnumSeverity$fBoundedSeverityInspectionAnalysisFindAstInfix LazyField BigTuplesPatternMatchOn_ UseCompareInspectionsMap Inspection inspectionIdinspectionNameinspectionDescriptioninspectionSolutioninspectionCategoryinspectionSeverityinspectionAnalysis descriptionL solutionL categoryL severityL analysisLsortByIdprettyShowInspectionprettyShowInspectionShort inspectionsMd$fShowInspectionAnalysis$fEqInspectionAnalysis$fShowInspection$fEqInspectionstyleInspectionsMapstan0301stan0302partialInspectionsMapstan0001stan0002stan0003stan0004stan0005stan0006stan0007stan0008stan0009stan0010stan0011stan0012stan0013stan0014stan0015stan0016stan0017stan0018stan0019stan0020stan0021infiniteInspectionsMapstan0101stan0102stan0103stan0104stan0105stan0106antiPatternInspectionsMapstan0201stan0202stan0203stan0204stan0205stan0206stan0207stan0208stan0209stan0210stan0211stan0212stan0213stan0214stan0215inspectionsMap inspectionsinspectionsIdslookupInspectionByIdgetInspectionById Observations Observation observationIdobservationInspectionIdobservationLocobservationFileobservationModuleNameobservationFileContent mkObservationprettyShowObservationprettyObservationSourceignoredObservationsprettyShowIgnoredObservationsmkObservationId$fShowObservation$fEqObservationFileMapFileInfo fileInfoPathfileInfoModuleName fileInfoLocfileInfoCabalExtensionsfileInfoExtensionsfileInfoMergedExtensionsfileInfoObservationsextensionsToTextisExtensionDisabled$fShowFileInfo $fEqFileInfoanalysisByInspectionAnalysisanalysisModulesNumanalysisLinesOfCodeanalysisUsedExtensionsanalysisInspectionsanalysisObservationsanalysisIgnoredObservationsanalysisFileMap runAnalysis$fShowAnalysis ProjectHealth Unhealthy LowHealth MediumHealthHealthyAnalysisNumbers anModulesanLocanExts anSafeExtsanIns anFoundObs anIgnoredObsanHealthprettyShowAnalysisanalysisToNumbers prettyHealthtoProjectHealthScope ScopeFileScopeDirectoryScopeAll CheckFilterCheckInspection CheckSeverity CheckCategoryCheckAllCheck checkType checkFilter checkScope CheckTypeIncludeExclude PartialConfigConfigConfigP configChecks configRemoved configIgnored defaultConfigfinaliseConfigconfigToCliCommandmkDefaultChecks applyConfig applyChecksapplyChecksFor$fSemigroupConfigP$fShowCheckType $fEqCheckType$fEnumCheckType$fBoundedCheckType$fShowCheckFilter$fEqCheckFilter $fShowScope $fEqScope $fShowCheck $fEqCheck $fEqConfigP $fShowConfigP ConfigAction RemoveAction IncludeAction ExcludeAction IgnoreActionprettyConfigActionconfigActionClassconfigActionColourconfigToTriplesprettyConfigCli$fShowConfigAction$fEqConfigAction CliToTomlArgscliToTomlArgsFilePathcliToTomlArgsConfig TomlToCliArgstomlToCliArgsFilePathInspectionArgsinspectionArgsIdStanArgsstanArgsHiedirstanArgsCabalFilePathstanArgsReportSettingsstanArgsReportstanArgsUseDefaultConfigFilestanArgsConfigFilestanArgsConfig StanCommandStanInspection StanTomlToCli StanCliToTomlStanInspectionsToMd runStanClistanParserPrefs stanCliParserSummarysummaryInspectionIdsummaryCategory summaryModulesummarySeverity createSummarystanHtmlgenerateReport usedTomlFiles getTomlConfig configCodecrunversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameghc-prim GHC.TypesTruefindCabalFilesfindCabalFileDirBoolFalsebaseGHC.BaseStringNonEmptyinteger-wired-inGHC.Integer.TypeInteger GHC.NaturalNatural text-1.2.4.0Data.Text.Internal maybePattern GHC.MaybeMaybe eitherPattern Data.EitherEither pairPatternFoldabletype_lazyRecordField GHC.ClassesEqOrelude-0.7.0.0-7ceaf357749ced580975b41f886062d3302379356cd89e2cf960ee6430cadb41 Relude.Debug undefinedcompare^unordered-containers-0.2.11.0-be8dc2916d88fe0346eb65964f3199a8f8b1887ea45ba518a421980d409ff9ecData.HashMap.BaseHashMapmkPartialInspectionPatternmkPartialInspectionmkPartialInspectionListmkPartialInspectionEnummkInfiniteInspectionreversemkAntiPatternInspectionfor_forM_ whenColourhashModuleName OperatorDeclOperator analyseAstanalyseBigTuplesanalyseCompareanalyseLazyFieldsanalysePatternMatch_ analyseInfixpartitionDeclscontainers-0.6.2.1Data.Map.InternalMapanalyseAstWith matchAstWith createMatchcreateMatchAstincLinesOfCodeaddInspectionsaddObservationsaddIgnoredObservations addExtensions updateFileMapGHC.IOFilePathanalyseanalyseHieFilestanstanPstanInspectionPtoggleSolutionP verbosityPidPversionP sdInspections sdCategories sdModules sdSeverityNothing maximumOn1_AllPtomland-1.3.0.0-aa66540d75ddaf0235fed9ef229f948750793176194690a9e2209c6651a5df34Toml.Codec.BiMapBiMap