Merge pull request #1374 from vasily-kirichenko/unused-declarations-fix

fixed: UnusedDeclarations.getSingleDeclarations returns actually used…

src/FSharpVSPowerTools.Core/LanguageService.fs

@@ -121,7 +121,7 @@ type WordSpan =
           Line = r.StartLine
           StartCol = r.StartColumn 
           EndCol = r.EndColumn }
-    member x.ToRange() = x.Line, x.StartCol, x.Line, x.EndCol
+    member x.Range = lazy (x.Line, x.StartCol, x.Line, x.EndCol)
 
 [<AbstractClass>]
 type LexerBase() = 

src/FSharpVSPowerTools.Core/TypedAstUtils.fs

@@ -299,28 +299,32 @@ module TypedAstPatterns =
 module UnusedDeclarations =
     open System.Collections.Generic
 
-    let symbolsComparer =
-        { new IEqualityComparer<FSharpSymbol> with
-              member __.Equals (x, y) = x.IsEffectivelySameAs y
-              member __.GetHashCode x = x.GetHashCode() }
+    let symbolUseComparer =
+        { new IEqualityComparer<FSharpSymbolUse> with
+              member __.Equals (x, y) = x.Symbol.IsEffectivelySameAs y.Symbol
+              member __.GetHashCode x = x.Symbol.GetHashCode() }
 
     let getSingleDeclarations (symbolsUses: SymbolUse[]): FSharpSymbol[] =
-        symbolsUses
-        |> Seq.groupBy (fun x -> x.SymbolUse.Symbol)
-        |> Seq.choose (fun (symbol, uses) ->
-            match symbol with
-            | UnionCase _ when isSymbolLocalForProject symbol -> Some symbol
+        let symbols = Dictionary<FSharpSymbolUse, int>(symbolUseComparer)
+
+        for symbolUse in symbolsUses do
+            match symbols.TryGetValue symbolUse.SymbolUse with
+            | true, count -> symbols.[symbolUse.SymbolUse] <- count + 1
+            | _ -> symbols.[symbolUse.SymbolUse] <- 1
+
+        symbols
+        |> Seq.choose (fun (KeyValue(symbolUse, count)) ->
+            match symbolUse.Symbol with
+            | UnionCase _ when isSymbolLocalForProject symbolUse.Symbol -> Some symbolUse.Symbol
             // Determining that a record, DU or module is used anywhere requires
             // inspecting all their enclosed entities (fields, cases and func / vals)
             // for usefulness, which is too expensive to do. Hence we never gray them out.
             | Entity ((Record | UnionType | Interface | FSharpModule), _, _ | Class) -> None
-            // FCS returns inconsistent results for override members; we're going to skip these symbols.
+            // FCS returns inconsistent results for override members; we're skipping these symbols.
             | MemberFunctionOrValue func when func.IsOverrideOrExplicitInterfaceImplementation -> None
             // Usage of DU case parameters does not give any meaningful feedback; we never gray them out.
             | Parameter -> None
-            | _ ->
-                match List.ofSeq uses with
-                | [symbolUse] when symbolUse.SymbolUse.IsFromDefinition && isSymbolLocalForProject symbol ->
-                    Some symbol 
+            | _ when count = 1 && symbolUse.IsFromDefinition && isSymbolLocalForProject symbolUse.Symbol ->
+                    Some symbolUse.Symbol
                 | _ -> None)
         |> Seq.toArray

src/FSharpVSPowerTools.Logic/ClassifierTypes.fs

@@ -17,7 +17,7 @@ type internal CategorizedSnapshotSpan (columnSpan: CategorizedColumnSpan<ITextSn
         snapshotSpan.Swap (fun oldSpan ->
             oldSpan
             |> Option.orTry (fun _ -> 
-                fromRange originalSnapshot (columnSpan.WordSpan.ToRange())
+                fromRange originalSnapshot columnSpan.WordSpan.Range.Value
                 |> Option.map (fun span -> 
                     { Span = span
                       Line = span.Start.GetContainingLine().LineNumber }))

src/FSharpVSPowerTools.Logic/UnusedSymbolClassifier.fs

@@ -114,17 +114,17 @@ type UnusedSymbolClassifier
 
             let! openDeclarations = OpenDeclarationGetter.getOpenDeclarations ast entities qualifyOpenDeclarations
             return
-                (entities
-                 |> Option.map (fun entities ->
-                     entities
-                     |> Seq.groupBy (fun e -> e.FullName)
-                     |> Seq.map (fun (fullName, entities) -> 
-                          fullName,
-                          entities
-                          |> Seq.map (fun e -> e.CleanedIdents) 
-                          |> Seq.toList)
-                     |> Dict.ofSeq),
-                openDeclarations)
+                entities
+                |> Option.map (fun entities ->
+                    entities
+                    |> Seq.groupBy (fun e -> e.FullName)
+                    |> Seq.map (fun (fullName, entities) -> 
+                         fullName,
+                         entities
+                         |> Seq.map (fun e -> e.CleanedIdents) 
+                         |> Seq.toList)
+                    |> Dict.ofSeq),
+                openDeclarations
         }
 
     let checkAstIsNotEmpty (ast: ParsedInput) =
@@ -265,7 +265,7 @@ type UnusedSymbolClassifier
 
                 match projects |> List.tryFind (fun p -> not p.Checked) with
                 | Some { Options = opts } ->
-                    // there is at least one yet unchecked project, start compilation on it
+                    // there is at least one yet unchecked project, start compiling it
                     vsLanguageService.CheckProjectInBackground opts
                 | None ->
                     // all the needed projects have been checked in background, let's calculate unused symbols
@@ -300,7 +300,7 @@ type UnusedSymbolClassifier
                 |> Option.map (fun data ->
                     data.Spans.Spans
                     |> Array.choose (fun wordSpan ->
-                        fromRange data.Snapshot (wordSpan.ColumnSpan.WordSpan.ToRange())
+                        fromRange data.Snapshot wordSpan.ColumnSpan.WordSpan.Range.Value
                         |> Option.map (fun span -> TagSpan(span, UnusedDeclarationTag()) :> ITagSpan<_>)))
                 |> Option.getOrElse [||]