WIP: fix SelfCheck

Author: knocte

src/FSharpLint.Console/Program.fs

@@ -175,9 +175,9 @@ let private lint
         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
 

src/FSharpLint.Core/Framework/AbstractSyntaxArray.fs

@@ -262,7 +262,7 @@ module AbstractSyntaxArray =
                 | Else(body) -> extractExtraInfo (Expression(body)) SyntaxNode.Else
                 | _ -> node
 
-            traverseNode node (fun node -> left.Push (StackedNode(node, depth + 1)))
+            traverseNode node (fun aNode -> left.Push (StackedNode(aNode, depth + 1)))
 
             match astNodeToSyntaxNode node with
             | SyntaxNode.Other -> ()

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/Utilities.fs

@@ -87,10 +87,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/Binding/TupleOfWildcards.fs

@@ -9,7 +9,7 @@ open FSharpLint.Framework.Rules
 
 let private checkTupleOfWildcards fileContents pattern identifier identifierRange =
     let rec isWildcard = function
-        | SynPat.Paren(pattern, _) -> isWildcard pattern
+        | SynPat.Paren(innerPattern, _) -> isWildcard innerPattern
         | SynPat.Wild(_) -> true
         | _ -> false
 

src/FSharpLint.Core/Rules/Smells/AsyncExceptionWithoutReturn.fs

@@ -17,28 +17,28 @@ let rec checkExpression (expression: SynExpr) (range: range) (continuation: unit
                 firstExpression
                 range
                 (fun () -> (checkExpression secondExpression secondExpression.Range returnEmptyArray))
-        | SynExpr.Paren (innerExpression, _, _, range) -> checkExpression innerExpression range returnEmptyArray
-        | SynExpr.While (_, _, innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
-        | SynExpr.For (_, _, _, _, _, _, _, innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
-        | SynExpr.ForEach (_, _, _, _, _, _, innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
-        | SynExpr.Match (_, _, clauses, range, _) ->
-            let subExpressions = clauses |> List.map (fun (SynMatchClause (_, _, clause, range, _, _)) -> (clause, range))
+        | SynExpr.Paren (innerExpression, _, _, innerRange) -> checkExpression innerExpression innerRange returnEmptyArray
+        | SynExpr.While (_, _, innerExpression, innerRange) -> checkExpression innerExpression innerRange returnEmptyArray
+        | SynExpr.For (_, _, _, _, _, _, _, innerExpression, innerRange) -> checkExpression innerExpression innerRange returnEmptyArray
+        | SynExpr.ForEach (_, _, _, _, _, _, innerExpression, innerRange) -> checkExpression innerExpression innerRange returnEmptyArray
+        | SynExpr.Match (_, _, clauses, innerRange, _) ->
+            let subExpressions = clauses |> List.map (fun (SynMatchClause (_, _, clause, innerRange, _, _)) -> (clause, innerRange))
             checkMultipleExpressions subExpressions returnEmptyArray
-        | SynExpr.Do (innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
+        | SynExpr.Do (innerExpression, innerRange) -> checkExpression innerExpression innerRange returnEmptyArray
         | SynExpr.TryWith (tryExpression, withCases, tryRange, _, _, _) ->
             let subExpressions =
                 withCases |> List.map (fun (SynMatchClause (_, _, withCase, withRange, _, _)) -> (withCase, withRange))
             checkMultipleExpressions subExpressions (fun () -> checkExpression tryExpression tryRange returnEmptyArray)
-        | SynExpr.TryFinally (tryExpression, finallyExpr, range, _, _, _) ->
-            checkExpression tryExpression range (fun () -> checkExpression finallyExpr range returnEmptyArray)
-        | SynExpr.IfThenElse (_, thenExpr, elseExpr, _, _, range, _) ->
+        | SynExpr.TryFinally (tryExpression, finallyExpr, innerRange, _, _, _) ->
+            checkExpression tryExpression range (fun () -> checkExpression finallyExpr innerRange returnEmptyArray)
+        | SynExpr.IfThenElse (_, thenExpr, elseExpr, _, _, innerRange, _) ->
             checkExpression
                 thenExpr
-                range
+                innerRange
                 (fun () -> 
                     match elseExpr with
                     | Some elseExpression ->
-                        checkExpression elseExpression range returnEmptyArray
+                        checkExpression elseExpression innerRange returnEmptyArray
                     | None -> Array.empty)
 
         | SynExpr.App (_, _, SynExpr.Ident failwithId, _, _) when
@@ -53,18 +53,18 @@ let rec checkExpression (expression: SynExpr) (range: range) (continuation: unit
                     SuggestedFix = None
                     TypeChecks = List.Empty
                 }
-        | SynExpr.App (_, _, funcExpr, _, range) ->
-            checkExpression funcExpr range returnEmptyArray
-        | SynExpr.LetOrUse (_, _, _, body, range, _) ->
-            checkExpression body range returnEmptyArray
+        | SynExpr.App (_, _, funcExpr, _, innerRange) ->
+            checkExpression funcExpr innerRange returnEmptyArray
+        | SynExpr.LetOrUse (_, _, _, body, innerRange, _) ->
+            checkExpression body innerRange returnEmptyArray
         | _ -> Array.empty)
         (continuation ())
 and [<TailCall>] checkMultipleExpressions (expressions: list<SynExpr * range>) (continuation: unit -> array<WarningDetails>) =
     match expressions with
-    | (expression, range) :: tail -> 
+    | (expression, innerRange) :: tail ->
         checkExpression
             expression
-            range
+            innerRange
             (fun () -> 
                 checkMultipleExpressions
                     tail