Core,Console,Tests: fix selfCheck

Co-authored-by: webwarrior-ws <reg@webwarrior.ws>

Author: knocte

src/FSharpLint.Console/Program.fs

@@ -109,25 +109,25 @@ let internal inferFileType (target:string) =
 
 /// Must be called only once per process.
 /// We're calling it globally so we can call main multiple times from our tests.
-let toolsPath = Ionide.ProjInfo.Init.init (DirectoryInfo <| Directory.GetCurrentDirectory())  None
+let globalToolsPath = Ionide.ProjInfo.Init.init (DirectoryInfo <| Directory.GetCurrentDirectory())  None
 
 [<EntryPoint>]
 let main argv =
+    let parserProgress (output:Output.IOutput) = function
+        | Starting file ->
+            String.Format(Resources.GetString("ConsoleStartingFile"), file) |> output.WriteInfo
+        | ReachedEnd (_, warnings) ->
+            String.Format(Resources.GetString("ConsoleFinishedFile"), List.length warnings) |> output.WriteInfo
+        | Failed (file, parseException) ->
+            String.Format(Resources.GetString("ConsoleFailedToParseFile"), file) |> output.WriteError
+            output.WriteError
+                $"Exception Message:{Environment.NewLine}{parseException.Message}{Environment.NewLine}Exception Stack Trace:{Environment.NewLine}{parseException.StackTrace}{Environment.NewLine}"
+
     let lint
         (lintArgs: ParseResults<LintArgs>)
         (output: Output.IOutput)
         (toolsPath:Ionide.ProjInfo.Types.ToolsPath)
         : ExitCode =
-        let parserProgress (output:Output.IOutput) = function
-            | Starting file ->
-                String.Format(Resources.GetString("ConsoleStartingFile"), file) |> output.WriteInfo
-            | ReachedEnd (_, warnings) ->
-                String.Format(Resources.GetString("ConsoleFinishedFile"), List.length warnings) |> output.WriteInfo
-            | Failed (file, parseException) ->
-                String.Format(Resources.GetString("ConsoleFailedToParseFile"), file) |> output.WriteError
-                output.WriteError
-                    $"Exception Message:{Environment.NewLine}{parseException.Message}{Environment.NewLine}Exception Stack Trace:{Environment.NewLine}{parseException.StackTrace}{Environment.NewLine}"
-
         let mutable exitCode = ExitCode.Success
 
         let handleError (str:string) =
@@ -181,9 +181,9 @@ let main argv =
             handleLintResult lintResult
         with
         | exn ->
-            let target = if fileType = FileType.Source then "source" else target
+            let targetStr = if fileType = FileType.Source then "source" else target
             handleError
-                $"Lint failed while analysing %s{target}.{Environment.NewLine}Failed with: %s{exn.Message}{Environment.NewLine}Stack trace: {exn.StackTrace}"
+                $"Lint failed while analysing %s{targetStr}.{Environment.NewLine}Failed with: %s{exn.Message}{Environment.NewLine}Stack trace: {exn.StackTrace}"
 
         exitCode
 
@@ -217,5 +217,5 @@ let main argv =
         | _ -> Some ConsoleColor.Red)
     let parser = ArgumentParser.Create<ToolArgs>(programName = "fsharplint", errorHandler = errorHandler)
     let parseResults = parser.ParseCommandLine argv
-    start parseResults toolsPath
+    start parseResults globalToolsPath
     |> int

src/FSharpLint.Core/Application/Configuration.fs

@@ -107,16 +107,14 @@ module IgnoreFiles =
         match remainingPath with
         | [_] when isDirectory -> false
         | currentSegment::remaining ->
-            let currentlyMatchingGlobs = globs::currentlyMatchingGlobs
+            let updatedCurrentlyMatchingGlobs = getRemainingGlobSeqForMatches currentSegment (globs::currentlyMatchingGlobs)
 
-            let currentlyMatchingGlobs = getRemainingGlobSeqForMatches currentSegment currentlyMatchingGlobs
-
-            let aGlobWasCompletelyMatched = List.exists List.isEmpty currentlyMatchingGlobs
+            let aGlobWasCompletelyMatched = List.exists List.isEmpty updatedCurrentlyMatchingGlobs
 
             let matched = aGlobWasCompletelyMatched && (isDirectory || (not isDirectory && List.isEmpty remaining))
 
             if matched then true
-            else doesGlobSeqMatchPathSeq globs isDirectory remaining currentlyMatchingGlobs
+            else doesGlobSeqMatchPathSeq globs isDirectory remaining updatedCurrentlyMatchingGlobs
         | [] -> false
 
     let private pathMatchesGlob (globs:Regex list) (path:string list) isDirectory =
@@ -692,7 +690,7 @@ let defaultConfiguration =
     use stream = assembly.GetManifestResourceStream(resourceName)
     match stream with
     | null -> failwithf "Resource '%s' not found in assembly '%s'" resourceName (assembly.FullName)
-    | stream ->
+    | _ ->
         use reader = new System.IO.StreamReader(stream)
 
         reader.ReadToEnd()
@@ -709,8 +707,8 @@ type LoadedRules =
       LineRules:LineRules
       DeprecatedRules:Rule [] }
 
-let getGlobalConfig (globalConfig:GlobalConfig option) =
-    globalConfig
+let getGlobalConfig (maybeGlobalConfig: GlobalConfig option) =
+    maybeGlobalConfig
     |> Option.map (fun globalConfig -> {
         Rules.GlobalRuleConfig.numIndentationSpaces = globalConfig.numIndentationSpaces |> Option.defaultValue Rules.GlobalRuleConfig.Default.numIndentationSpaces
     }) |> Option.defaultValue Rules.GlobalRuleConfig.Default
@@ -751,11 +749,11 @@ let findDeprecation config deprecatedAllRules allRules =
 // fsharplint:disable MaxLinesInFunction
 let flattenConfig (config:Configuration) =
     let parseHints (hints:string []) =
-        let parseHint hint =
-            match FParsec.CharParsers.run HintParser.phint hint with
+        let parseHint hintString =
+            match FParsec.CharParsers.run HintParser.phint hintString with
             | FParsec.CharParsers.Success(hint, _, _) -> hint
             | FParsec.CharParsers.Failure(error, _, _) ->
-                raise <| ConfigurationException $"Failed to parse hint: {hint}{Environment.NewLine}{error}"
+                raise <| ConfigurationException $"Failed to parse hint: {hintString}{Environment.NewLine}{error}"
 
         hints
         |> Array.filter (System.String.IsNullOrWhiteSpace >> not)
@@ -769,12 +767,12 @@ let flattenConfig (config:Configuration) =
         Array.concat
             [|
                 // Deprecated grouped configs. TODO: remove in next major release
-                config.formatting |> Option.map (fun config -> config.Flatten()) |> Option.toArray |> Array.concat
-                config.conventions |> Option.map (fun config -> config.Flatten()) |> Option.toArray |> Array.concat
-                config.typography |> Option.map (fun config -> config.Flatten()) |> Option.toArray |> Array.concat
+                config.formatting |> Option.map (fun formattingConfig -> formattingConfig.Flatten()) |> Option.toArray |> Array.concat
+                config.conventions |> Option.map (fun conventionsConfig -> conventionsConfig.Flatten()) |> Option.toArray |> Array.concat
+                config.typography |> Option.map (fun typographyConfig -> typographyConfig.Flatten()) |> Option.toArray |> Array.concat
                 // </Deprecated>
 
-                config.Hints |> Option.map (fun config -> HintMatcher.rule { HintMatcher.Config.HintTrie = parseHints (getOrEmptyList config.add) }) |> Option.toArray
+                config.Hints |> Option.map (fun hintsConfig -> HintMatcher.rule { HintMatcher.Config.HintTrie = parseHints (getOrEmptyList hintsConfig.add) }) |> Option.toArray
             |]
 
     let allRules =

src/FSharpLint.Core/Application/Lint.fs

@@ -523,12 +523,12 @@ module Lint =
 
                     let (successes, failures) =
                         lintResults
-                        |> Array.fold (fun (successes, failures) result ->
+                        |> Array.fold (fun (successList, failureList) result ->
                             match result with
                             | LintResult.Success warnings ->
-                                (List.append warnings successes, failures)
+                                (List.append warnings successList, failureList)
                             | LintResult.Failure err ->
-                                (successes, err :: failures)) (List.Empty, List.Empty)
+                                (successList, err :: failureList)) (List.Empty, List.Empty)
 
                     match failures with
                     | [] ->

src/FSharpLint.Core/Framework/AbstractSyntaxArray.fs

@@ -250,7 +250,7 @@ module AbstractSyntaxArray =
             tryAddPossibleSkips depth
 
             // Strip out "extra info".
-            let node =
+            let strippedNode =
                 let extractExtraInfo actual extraInfoNode =
                     possibleSkips.Push (PossibleSkip(nodes.Count, depth))
                     nodes.Add (TempNode(Utilities.hash2 extraInfoNode 0, actual))
@@ -262,13 +262,13 @@ module AbstractSyntaxArray =
                 | Else(body) -> extractExtraInfo (Expression(body)) SyntaxNode.Else
                 | _ -> node
 
-            traverseNode node (fun node -> left.Push (StackedNode(node, depth + 1)))
+            traverseNode strippedNode (fun aNode -> left.Push (StackedNode(aNode, depth + 1)))
 
-            match astNodeToSyntaxNode node with
+            match astNodeToSyntaxNode strippedNode with
             | SyntaxNode.Other -> ()
             | syntaxNode ->
                 possibleSkips.Push (PossibleSkip(nodes.Count, depth))
-                nodes.Add (TempNode(Utilities.hash2 syntaxNode (getHashCode node), node))
+                nodes.Add (TempNode(Utilities.hash2 syntaxNode (getHashCode strippedNode), strippedNode))
 
         tryAddPossibleSkips 0
 

src/FSharpLint.Core/Framework/AstInfo.fs

@@ -120,9 +120,9 @@ module AstInfo =
         if Seq.isEmpty str then
             true
         else
-            let operator = List.tryFind (fun (op: string) -> str.StartsWith(op)) operators
+            let maybeOperator = List.tryFind (fun (op: string) -> str.StartsWith(op)) operators
 
-            match operator with
+            match maybeOperator with
             | Some(operator) -> str.Substring(operator.Length) |> isSequenceOfOperators
             | None -> false
 

src/FSharpLint.Core/Framework/HintParser.fs

@@ -83,9 +83,9 @@ module HintParser =
                 [ attempt pident
                   .>>. many (attempt (skipChar '.' >>. pident))
                   .>>. opt (skipChar '.' >>. pidentorop)
-                  |>> (fun ((startIdent, idents), operator) ->
+                  |>> (fun ((startIdent, idents), maybeOperator) ->
                       let identifiers = startIdent::idents
-                      match operator with
+                      match maybeOperator with
                       | Some(operator) -> identifiers@[operator]
                       | None -> identifiers)
                   attempt (pidentorop |>> fun identOrOpChars -> [identOrOpChars])

src/FSharpLint.Core/Framework/Suppression.fs

@@ -16,7 +16,7 @@ type SuppressionInfo =
 type LineSuppression = { Line:int; Suppressions:SuppressionInfo list }
 
 /// Parses a given file to find lines containing rule suppressions.
-let parseSuppressionInfo (rules:Set<String>) (lines:string list) =
+let parseSuppressionInfo (originalRuleNames:Set<String>) (lines:string list) =
     /// Extracts rule names from a whitespace separated string of rule names.
     let extractRules (rules:Set<String>) (str:string) =
         let (splitOnWhitespace:char[]) = null
@@ -29,16 +29,16 @@ let parseSuppressionInfo (rules:Set<String>) (lines:string list) =
         // If no rules set, then all rules are applied.
         if Seq.isEmpty entries then rules else entries
 
-    let rules = Set.map (fun (rule: String) -> rule.ToLowerInvariant()) rules
+    let lowerCasedRules = Set.map (fun (rule: String) -> rule.ToLowerInvariant()) originalRuleNames
 
     let choose lineNum line = 
         let matched = Regex.Match (line, ".*fsharplint:([a-z\-]+)\s*(.*)$")
         if matched.Success then
             let suppressionTarget =
                 if matched.Groups.Count = 3 then
-                    extractRules rules matched.Groups.[2].Value
+                    extractRules lowerCasedRules matched.Groups.[2].Value
                 else
-                    rules
+                    lowerCasedRules
             match matched.Groups.[1].Value with
             | "enable" -> Some (lineNum, Enable suppressionTarget)
             | "disable" -> Some (lineNum, Disable suppressionTarget)
@@ -62,26 +62,25 @@ let isSuppressed (rule:String) (line:int) (lineSuppressions:LineSuppression list
     if List.isEmpty lineSuppressions then
         false
     else
-        let rule = rule.ToLowerInvariant()
-            
+        let ruleLowercase = rule.ToLowerInvariant()
 
         let fold (disabledRules:Set<String>) (lineSuppression:LineSuppression) = 
-            let innerFold (disabledRules:Set<String>) suppression = 
+            let innerFold (currentDisabledRules:Set<String>) suppression = 
                 match suppression with
                 | Enable(rules) ->
-                    Set.difference disabledRules rules
+                    Set.difference currentDisabledRules rules
                 | Disable(rules) ->
-                    Set.union disabledRules rules
+                    Set.union currentDisabledRules rules
                 | DisableLine(rules) ->
                     if line = lineSuppression.Line then
-                        Set.union disabledRules rules
+                        Set.union currentDisabledRules rules
                     else
-                        disabledRules
+                        currentDisabledRules
             List.fold innerFold disabledRules lineSuppression.Suppressions
 
         let disabledRules =
             lineSuppressions
             |> List.takeWhile (fun lineSupression -> lineSupression.Line <= line)
             |> List.fold fold Set.empty
 
-        disabledRules.Contains(rule)
+        disabledRules.Contains(ruleLowercase)

src/FSharpLint.Core/Framework/Utilities.fs

@@ -88,10 +88,10 @@ module ExpressionUtilities =
 
     /// Tries to find the source code within a given range.
     let tryFindTextOfRange (range:Range) (text:string) =
-        let startIndex = findPos range.Start text
-        let endIndex = findPos range.End text
+        let maybeStartIndex = findPos range.Start text
+        let maybeEndIndex = findPos range.End text
 
-        match (startIndex, endIndex) with
+        match (maybeStartIndex, maybeEndIndex) with
         | Some(startIndex), Some(endIndex) ->
             text.Substring(startIndex, endIndex - startIndex) |> Some
         | _ -> None

src/FSharpLint.Core/Rules/Conventions/AvoidSinglePipeOperator.fs

@@ -91,7 +91,7 @@ and [<TailCall>] private checkExprContinuationPassingStyle (arguments: CheckExpr
         arguments.Continuation Array.empty
 
 let runner (args: AstNodeRuleParams) =
-    let checkExpr (args: AstNodeRuleParams) (expr: SynExpr) (outerArgExpr: SynExpr) (range: FSharp.Compiler.Text.range) (parentList: AstNode list): WarningDetails array =
+    let checkExpr (expr: SynExpr) (outerArgExpr: SynExpr) (range: FSharp.Compiler.Text.range) (parentList: AstNode list): WarningDetails array =
         checkExprContinuationPassingStyle 
             { 
                 Args = args
@@ -110,7 +110,7 @@ let runner (args: AstNodeRuleParams) =
                 // function has extra arguments
                 Array.empty
             | _ ->
-                checkExpr args funcExpr argExpr range (args.GetParents args.NodeIndex)
+                checkExpr funcExpr argExpr range (args.GetParents args.NodeIndex)
         | _ ->
             Array.empty
 

src/FSharpLint.Core/Rules/Conventions/Binding/FavourAsKeyword.fs

@@ -9,7 +9,7 @@ open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
 let private runner (args:AstNodeRuleParams) =
-    let checkForNamedPatternEqualsConstant (args:AstNodeRuleParams) pattern whenExpr (range:Range) =
+    let checkForNamedPatternEqualsConstant pattern whenExpr (range:Range) =
         let patternIdent =
             match pattern with
             | SynPat.Named(SynIdent.SynIdent(ident, _), _, _, _) -> Some(ident.idText)
@@ -45,7 +45,7 @@ let private runner (args:AstNodeRuleParams) =
 
     match args.AstNode with
     | AstNode.Match(SynMatchClause.SynMatchClause(pat, Some(whenExpr), _, range, _, _)) ->
-        checkForNamedPatternEqualsConstant args pat whenExpr range
+        checkForNamedPatternEqualsConstant pat whenExpr range
 
     | _ -> Array.empty