DisallowShadowing: fix selfCheck violations in rule code

Author: webwarrior-ws

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

@@ -8,19 +8,69 @@ open FSharpLint.Framework.Suggestion
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
-let private extractIdentifiersFromSimplePats (simplePats: SynSimplePats) : List<Ident> =
-    let rec extractIdentifier (pattern: SynSimplePat) =
-        match pattern with
-        | SynSimplePat.Id(ident, _, _, _, _, _) ->
-            ident
-        | SynSimplePat.Attrib(pat, _, _)
-        | SynSimplePat.Typed(pat, _, _) ->
-            extractIdentifier pat
+[<TailCall>]
+let rec private extractIdentifier (pattern: SynSimplePat) =
+    match pattern with
+    | SynSimplePat.Id(ident, _, _, _, _, _) ->
+        ident
+    | SynSimplePat.Attrib(pat, _, _)
+    | SynSimplePat.Typed(pat, _, _) ->
+        extractIdentifier pat
 
+let private extractIdentifiersFromSimplePats (simplePats: SynSimplePats) : List<Ident> =
     match simplePats with
     | SynSimplePats.SimplePats(patterns, _, _) ->
         patterns |> List.map extractIdentifier
 
+let private rangeIncludesDefinitions (definitions: array<FSharpSymbolUse>) range =
+    definitions
+    |> Array.exists (fun usage -> ExpressionUtilities.rangeContainsOtherRange range usage.Range)
+
+[<TailCall>]
+let rec private processExpressions 
+    (processBinding: SynBinding -> bool)
+    (processArgs: SynSimplePats -> bool)
+    (expressions: list<SynExpr>) =
+    match expressions with
+    | SynExpr.LetOrUse(_, _, bindings, _, _, _) :: rest ->
+        bindings |> List.exists processBinding
+        || processExpressions processBinding processArgs rest
+    | SynExpr.Sequential(_, _, expr1, expr2, _, _) :: rest ->
+        processExpressions processBinding processArgs (expr1 :: expr2 :: rest)
+    | SynExpr.Lambda(_, _, arguments, body, _, _, _) :: rest ->
+        processArgs arguments
+        || processExpressions processBinding processArgs (body :: rest)
+    | _ -> false
+
+[<TailCall>]
+let rec private processPatterns (definitionsAndPatterns: list<array<FSharpSymbolUse> * SynPat>) =
+    match definitionsAndPatterns with
+    | (definitions, SynPat.Named(SynIdent(ident, _), _, _, _)) :: rest -> 
+        rangeIncludesDefinitions definitions ident.idRange
+        || processPatterns rest
+    | (definitions, SynPat.Ands(pats, _)) :: rest ->
+        processPatterns ((pats |> List.map (fun pat -> (definitions, pat))) @ rest)
+    | (definitions, SynPat.Or(lhs, rhs, _, _)) :: rest ->
+        let definitionsExcludingLhs =
+            definitions
+            |> Array.filter (fun usage -> not <| ExpressionUtilities.rangeContainsOtherRange lhs.Range usage.Range)
+        processPatterns ([ (definitionsExcludingLhs, lhs); (definitionsExcludingLhs, rhs) ] @ rest)
+    | (definitions, SynPat.ArrayOrList(_, pats, _)) :: rest -> 
+        processPatterns ((pats |> List.map (fun pat -> (definitions, pat))) @ rest)
+    | (definitions, SynPat.As(_lhs, rhs, _)) :: rest -> 
+        processPatterns ((definitions, rhs) :: rest)
+    | (definitions, SynPat.OptionalVal(ident, _)) :: rest ->
+        rangeIncludesDefinitions definitions ident.idRange
+        || processPatterns rest
+    | (definitions, SynPat.Paren(pat, _)) :: rest ->
+        processPatterns ((definitions, pat) :: rest)
+    | (definitions, SynPat.Record(fieldPats, _)) :: rest ->
+        processPatterns ((fieldPats |> List.map (fun (_, _, pat) -> (definitions, pat))) @ rest)
+    | (definitions, SynPat.Tuple(_, pats, _, _)) :: rest ->
+        processPatterns ((pats |> List.map (fun pat -> (definitions, pat))) @ rest)
+    | (definitions, SynPat.Typed(pat, _, _)) :: rest ->
+        processPatterns ((definitions, pat) :: rest)
+    | _ -> false
 
 let private checkIdentifier (args: AstNodeRuleParams) (identifier: Ident) : array<WarningDetails> =
     let name = identifier.idText
@@ -39,67 +89,35 @@ let private checkIdentifier (args: AstNodeRuleParams) (identifier: Ident) : arra
                         < (identifier.idRange.StartLine, identifier.idRange.StartColumn) )
             |> Seq.toArray
 
-        let rangeIncludedsDefinitions (definitions: array<FSharpSymbolUse>) range =
-            definitions
-            |> Array.exists (fun usage -> ExpressionUtilities.rangeContainsOtherRange range usage.Range)
-
-        let rangeIncludedsDefinitionsBeforeCurrent =
-            rangeIncludedsDefinitions definitionsBeforeCurrent
+        let rangeIncludesDefinitionsBeforeCurrent =
+            rangeIncludesDefinitions definitionsBeforeCurrent
 
         let processBinding (binding: SynBinding) =
             if ExpressionUtilities.rangeContainsOtherRange binding.RangeOfBindingWithRhs identifier.idRange then
                 // inside binding's scope
-                rangeIncludedsDefinitionsBeforeCurrent binding.RangeOfHeadPattern
+                rangeIncludesDefinitionsBeforeCurrent binding.RangeOfHeadPattern
             else
                 // outside binding's scope
                 match binding with
                 | SynBinding(_, _, _, _, _, _, _, headPat, _, _, _, _, _) ->
                     match headPat with
-                    | SynPat.Named(SynIdent(ident, _), _, _, _) -> rangeIncludedsDefinitionsBeforeCurrent ident.idRange
+                    | SynPat.Named(SynIdent(ident, _), _, _, _) -> rangeIncludesDefinitionsBeforeCurrent ident.idRange
                     | SynPat.LongIdent(SynLongIdent([ ident ], _, _), _, _, _, _, _) -> 
-                        rangeIncludedsDefinitionsBeforeCurrent ident.idRange
+                        rangeIncludesDefinitionsBeforeCurrent ident.idRange
                     | _ -> false
 
-        let processArgs (args: SynSimplePats) =
-            args
+        let processArgs (arguments: SynSimplePats) =
+            arguments
             |> extractIdentifiersFromSimplePats
-            |> List.exists (fun ident -> rangeIncludedsDefinitionsBeforeCurrent ident.idRange)
-
-        let rec processExpression (expression: SynExpr) =
-            match expression with
-            | SynExpr.LetOrUse(_, _, bindings, _, _, _) ->
-                bindings |> List.exists processBinding
-            | SynExpr.Sequential(_, _, expr1, expr2, _, _) ->
-                processExpression expr1 || processExpression expr2
-            | SynExpr.Lambda(_, _, args, body, _, _, _) ->
-                processExpression body || processArgs args
-            | _ -> false
-
-        let rec processPattern (definitions: array<FSharpSymbolUse>) (pattern: SynPat) =
-            match pattern with
-            | SynPat.Named(SynIdent(ident, _), _, _, _) -> rangeIncludedsDefinitions definitions ident.idRange
-            | SynPat.Ands(pats, _) -> pats |> List.exists (processPattern definitions)
-            | SynPat.Or(lhs, rhs, _, _) ->
-                let definitionsExcludingLhs =
-                    definitions
-                    |> Array.filter (fun usage -> not <| ExpressionUtilities.rangeContainsOtherRange lhs.Range usage.Range)
-                processPattern definitionsExcludingLhs lhs || processPattern definitionsExcludingLhs rhs
-            | SynPat.ArrayOrList(_, pats, _) -> pats |> List.exists (processPattern definitions)
-            | SynPat.As(_lhs, rhs, _) -> processPattern definitions rhs
-            | SynPat.OptionalVal(ident, _) -> rangeIncludedsDefinitions definitions ident.idRange
-            | SynPat.Paren(pat, _) -> processPattern definitions pat
-            | SynPat.Record(fieldPats, _) -> fieldPats |> List.exists (fun (_, _, pat) -> processPattern definitions pat)
-            | SynPat.Tuple(_, pats, _, _) -> pats |> List.exists (processPattern definitions)
-            | SynPat.Typed(pat, _, _) -> processPattern definitions pat
-            | _ -> false
+            |> List.exists (fun ident -> rangeIncludesDefinitionsBeforeCurrent ident.idRange)
 
         let processModuleDeclaration (moduleDecl: SynModuleDecl) =
             match moduleDecl with
-            | SynModuleDecl.Let(_, bindings, _) ->
-                bindings 
-                |> List.exists processBinding
+            | SynModuleDecl.Let(_, bindings, _) -> bindings |> List.exists processBinding
             | _ -> false
 
+        let processExpression (expr: SynExpr) = processExpressions processBinding processArgs (List.singleton expr)
+
         let processAstNode (node: AstNode) =
             match node with
             | ModuleOrNamespace(SynModuleOrNamespace(_, _, _, declarations, _, _, _, _, _)) ->
@@ -110,11 +128,11 @@ let private checkIdentifier (args: AstNodeRuleParams) (identifier: Ident) : arra
                 processExpression lambda.Body
                 || (lambda.Arguments |> List.exists processArgs)
             | Match(SynMatchClause(pattern, _, _, _, _, _)) ->
-                processPattern definitionsBeforeCurrent pattern
+                processPatterns (List.singleton (definitionsBeforeCurrent, pattern))
             | MemberDefinition(SynMemberDefn.Member(memberDefn, _)) ->
                 processBinding memberDefn
             | TypeDefinition(SynTypeDefn(_, _, _, Some(SynMemberDefn.ImplicitCtor(_, _, ctorArgs, _, _, _, _)), _, _)) ->
-                processPattern definitionsBeforeCurrent ctorArgs
+                processPatterns (List.singleton (definitionsBeforeCurrent, ctorArgs))
             | _ -> false
 
         let parents = args.GetParents args.NodeIndex