Unused declarations analyzer (dotnet#2358)

* add UnusedDeclarationsAnalyzer

* fix compilation

* make UnusedDeclarationsAnalyzer work on private symbols only

* fix compilation

UnusedDeclarationsAnalyzer analyze semantic, not syntax

* finish UnusedDeclarationsAnalyzer

* do not mark as unused symbols prefixed with underscore

* fix FSharp.Editor.Pervasive.isScript

* UnusedDeclarationsAnalyzer consider all declaration in scripts as private to file

Author: vasily-kirichenko

vsintegration/src/FSharp.Editor/Common/Pervasive.fs

@@ -9,12 +9,12 @@ open System.Diagnostics
 
 /// Checks if the filePath ends with ".fsi"
 let isSignatureFile (filePath:string) = 
-    Path.GetExtension filePath = ".fsi"
+    String.Equals (Path.GetExtension filePath, ".fsi", StringComparison.OrdinalIgnoreCase)
 
 /// Checks if the file paht ends with '.fsx' or '.fsscript'
 let isScriptFile (filePath:string) = 
     let ext = Path.GetExtension filePath 
-    String.Equals (ext,".fsi",StringComparison.OrdinalIgnoreCase) || String.Equals (ext,".fsscript",StringComparison.OrdinalIgnoreCase)
+    String.Equals (ext, ".fsx", StringComparison.OrdinalIgnoreCase) || String.Equals (ext, ".fsscript", StringComparison.OrdinalIgnoreCase)
 
 /// Path combination operator
 let (</>) path1 path2 = Path.Combine (path1, path2) 

vsintegration/src/FSharp.Editor/Diagnostics/UnusedDeclarationsAnalyzer.fs

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace rec Microsoft.VisualStudio.FSharp.Editor
+
+open System
+open System.Collections.Immutable
+open System.Threading.Tasks
+open System.Collections.Generic
+
+open Microsoft.CodeAnalysis
+open Microsoft.CodeAnalysis.Diagnostics
+open Microsoft.FSharp.Compiler.SourceCodeServices
+
+[<DiagnosticAnalyzer(FSharpConstants.FSharpLanguageName)>]
+type internal UnusedDeclarationsAnalyzer() =
+    inherit DocumentDiagnosticAnalyzer()
+    
+    let getProjectInfoManager (document: Document) = document.Project.Solution.Workspace.Services.GetService<FSharpCheckerWorkspaceService>().ProjectInfoManager
+    let getChecker (document: Document) = document.Project.Solution.Workspace.Services.GetService<FSharpCheckerWorkspaceService>().Checker
+    let [<Literal>] DescriptorId = "FS1182"
+    
+    let Descriptor = 
+        DiagnosticDescriptor(
+            id = DescriptorId,
+            title = SR.TheValueIsUnused.Value,
+            messageFormat = SR.TheValueIsUnused.Value,
+            category = DiagnosticCategory.Style,
+            defaultSeverity = DiagnosticSeverity.Hidden,
+            isEnabledByDefault = true,
+            customTags = DiagnosticCustomTags.Unnecessary)
+    
+    let symbolUseComparer =
+        { new IEqualityComparer<FSharpSymbolUse> with
+            member __.Equals (x, y) = x.Symbol.IsEffectivelySameAs y.Symbol
+            member __.GetHashCode x = x.Symbol.GetHashCode() }
+
+    let countSymbolsUses (symbolsUses: FSharpSymbolUse[]) =
+        let result = Dictionary<FSharpSymbolUse, int>(symbolUseComparer)
+    
+        for symbolUse in symbolsUses do
+            match result.TryGetValue symbolUse with
+            | true, count -> result.[symbolUse] <- count + 1
+            | _ -> result.[symbolUse] <- 1
+        result
+
+    let getSingleDeclarations (symbolsUses: FSharpSymbolUse[]) (isScript: bool) =
+        let declarations =
+            countSymbolsUses symbolsUses
+            |> Seq.choose (fun (KeyValue(symbolUse, count)) ->
+                match symbolUse.Symbol with
+                // Determining that a record, DU or module is used anywhere requires inspecting all their enclosed entities (fields, cases and func / vals)
+                // for usages, which is too expensive to do. Hence we never gray them out.
+                | :? FSharpEntity as e when e.IsFSharpRecord || e.IsFSharpUnion || e.IsInterface || e.IsFSharpModule || e.IsClass -> None
+                // FCS returns inconsistent results for override members; we're skipping these symbols.
+                | :? FSharpMemberOrFunctionOrValue as f when 
+                        f.IsOverrideOrExplicitInterfaceImplementation ||
+                        f.IsConstructorThisValue ||
+                        f.IsBaseValue ||
+                        f.IsConstructor -> None
+                // Usage of DU case parameters does not give any meaningful feedback; we never gray them out.
+                | :? FSharpParameter when symbolUse.IsFromDefinition -> None
+                | _ when count = 1 && symbolUse.IsFromDefinition && (isScript || symbolUse.IsPrivateToFile) -> Some symbolUse
+                | _ -> None)
+        HashSet(declarations, symbolUseComparer)
+
+    override __.SupportedDiagnostics = ImmutableArray.Create Descriptor
+    
+    override this.AnalyzeSyntaxAsync(_, _) = Task.FromResult ImmutableArray<Diagnostic>.Empty
+
+    override this.AnalyzeSemanticsAsync(document, cancellationToken) =
+        asyncMaybe {
+            match getProjectInfoManager(document).TryGetOptionsForEditingDocumentOrProject(document) with
+            | Some options ->
+                let! sourceText = document.GetTextAsync()
+                let checker = getChecker document
+                let! _, _, checkResults = checker.ParseAndCheckDocument(document, options, sourceText = sourceText, allowStaleResults = true)
+                let! allSymbolUsesInFile = checkResults.GetAllUsesOfAllSymbolsInFile() |> liftAsync
+                let unusedDeclarations = getSingleDeclarations allSymbolUsesInFile (isScriptFile document.FilePath)
+                return 
+                    unusedDeclarations
+                    |> Seq.filter (fun symbolUse -> not (symbolUse.Symbol.DisplayName.StartsWith "_"))
+                    |> Seq.map (fun symbolUse -> Diagnostic.Create(Descriptor, RoslynHelpers.RangeToLocation(symbolUse.RangeAlternate, sourceText, document.FilePath)))
+                    |> Seq.toImmutableArray
+            | None -> return ImmutableArray.Empty
+        }
+        |> Async.map (Option.defaultValue ImmutableArray.Empty)
+        |> RoslynHelpers.StartAsyncAsTask cancellationToken
+
+    interface IBuiltInAnalyzer with
+        member __.OpenFileOnly _ = true
+        member __.GetAnalyzerCategory() = DiagnosticAnalyzerCategory.SemanticDocumentAnalysis

vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj

@@ -58,6 +58,7 @@
     <Compile Include="Diagnostics\DocumentDiagnosticAnalyzer.fs" />
     <Compile Include="Diagnostics\ProjectDiagnosticAnalyzer.fs" />
     <Compile Include="Diagnostics\SimplifyNameDiagnosticAnalyzer.fs" />
+    <Compile Include="Diagnostics\UnusedDeclarationsAnalyzer.fs" />
     <Compile Include="Diagnostics\UnusedOpensDiagnosticAnalyzer.fs" />
     <Compile Include="Completion\CompletionUtils.fs" />
     <Compile Include="Completion\CompletionProvider.fs" />

vsintegration/src/FSharp.Editor/FSharp.Editor.resx

@@ -174,4 +174,7 @@
   <data name="6010" xml:space="preserve">
     <value>Code Fixes</value>
   </data>
+  <data name="TheValueIsUnused" xml:space="preserve">
+    <value>The value is unused</value>
+  </data>
 </root>

vsintegration/src/FSharp.Editor/srFSharp.Editor.fs

@@ -29,6 +29,7 @@ module SR =
     let FSharpPrintfFormatClassificationType = lazy (GetString "FSharpPrintfFormatClassificationType")
     let FSharpPropertiesClassificationType = lazy (GetString "FSharpPropertiesClassificationType")
     let FSharpDisposablesClassificationType = lazy (GetString "FSharpDisposablesClassificationType")
+    let TheValueIsUnused = lazy (GetString "TheValueIsUnused")
     let RemoveUnusedOpens = lazy (GetString "RemoveUnusedOpens")
     let UnusedOpens = lazy (GetString "UnusedOpens")
     let AddProjectReference = lazy (GetString "AddProjectReference")