UsedUnderscorePrefixedElements: implement quick fix

Implement quick fix for UsedUnderscorePrefixedElements. Quick
fix is only applied if no other identifiers with suggested name
(without underscore) exist. There are cases when such
identifiers exist, but not in the same scope, and stil no quick
fix is applied.

Co-authored-by: Mehrshad <[email protected]>

Author: webwarrior-ws

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

@@ -2,11 +2,11 @@ module FSharpLint.Rules.UsedUnderscorePrefixedElements
 
 open System
 
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.CodeAnalysis
+
 open FSharpLint.Framework
 open FSharpLint.Framework.Suggestion
-open FSharp.Compiler.Syntax
-open FSharp.Compiler.Text
-open FSharp.Compiler.CodeAnalysis
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
@@ -15,21 +15,44 @@ let runner (args: AstNodeRuleParams) =
     if args.NodeIndex = 0 then
         match args.CheckInfo with
         | Some checkResults -> 
-            checkResults.GetAllUsesOfAllSymbolsInFile() 
-            |> Seq.choose (fun usage ->
-                match usage.Symbol with
-                | :? FSharp.Compiler.Symbols.FSharpMemberOrFunctionOrValue as symbol -> 
-                    if not usage.IsFromDefinition && symbol.FullName.StartsWith "_" 
-                            && symbol.FullName <> "_" && not symbol.IsCompilerGenerated then
-                        Some {
-                            Range = usage.Range
-                            Message = String.Format(Resources.GetString ("RulesUsedUnderscorePrefixedElements"))
-                            SuggestedFix = None
-                            TypeChecks = List.Empty
-                        }
-                    else
-                        None
-                | _ -> None )
+            let allUsages = checkResults.GetAllUsesOfAllSymbolsInFile() |> Seq.toArray
+            seq {
+                for usage in allUsages do
+                    match usage.Symbol with
+                    | :? FSharpMemberOrFunctionOrValue as symbol -> 
+                        if not usage.IsFromDefinition && symbol.DisplayName.StartsWith "_" 
+                                && symbol.DisplayName <> "_" && not symbol.IsCompilerGenerated && not symbol.IsMember then
+                            let nameWithoutUnderscore = symbol.DisplayName.[1..]
+                            let clashesWithOtherDefinitions =
+                                allUsages
+                                |> Array.filter 
+                                    (fun each -> each.Symbol.DisplayName = nameWithoutUnderscore && each.IsFromDefinition)
+                                |> Array.isEmpty
+                                |> not
+                                
+                            if clashesWithOtherDefinitions then
+                                yield {
+                                    Range = usage.Range
+                                    Message = Resources.GetString ("RulesUsedUnderscorePrefixedElements")
+                                    SuggestedFix = None
+                                    TypeChecks = List.Empty
+                                }
+                            else
+                                for range in [usage.Range; symbol.DeclarationLocation] do
+                                    let warningDetrails = 
+                                        lazy(
+                                            let fromText = symbol.DisplayName
+                                            Some { FromRange = range; FromText = fromText; ToText = nameWithoutUnderscore })
+                                    yield {
+                                        Range = range
+                                        Message = Resources.GetString ("RulesUsedUnderscorePrefixedElements")
+                                        SuggestedFix = Some warningDetrails
+                                        TypeChecks = List.Empty
+                                    }
+                        else
+                            ()
+                    | _ -> () }
+            |> Seq.distinctBy (fun wargningDetails -> wargningDetails.Range)
             |> Seq.toArray
         | None -> Array.empty
     else