anchor.diff:      // We want to filter all of them but the longest one (Method).
       let symbolUsesWithoutNested =
           symbolUsesPotentiallyRequireOpenDecls
  -        |> Seq.groupBy (fun symbolUse -> symbolUse.SymbolUse.RangeAlternate.StartLine)
  -        |> Seq.map (fun (line, symbolUses) ->
  -            // We use LongIdents collected from the untyped AST to determine that a bunch of entities
  -            // actually represents a single entity. 
  -            match longIdentsByLine |> Map.tryFind line with
  -            | Some longIdents ->
  -                // Group all SymbolUses by LongIdents in which they are belong (by ranges).
  -                symbolUses
  -                |> Seq.map (fun sUse -> 
  -                    sUse, longIdents |> Seq.tryFind (fun (r, _) -> Range.rangeContainsRange r sUse.SymbolUse.RangeAlternate))
  -                |> Seq.groupBy (fun (_, longIdent) -> longIdent)
  -                |> Seq.map (fun (longIdent, symbolUses) -> 
  -                    match longIdent with
  -                    | Some _ ->
  -                        (* Find all longest SymbolUses which has unique roots. For example:
  +        |> Array.map (fun sUse ->
  +            match longIdentsByEndPos.TryGetValue sUse.SymbolUse.RangeAlternate.End with
  +            | true, longIdent -> sUse, Some longIdent
  +            | _ -> sUse, None)
  +        |> Seq.groupBy (fun (_, longIdent) -> longIdent)
  +        |> Seq.map (fun (longIdent, sUses) -> longIdent, sUses |> Seq.map fst)
  +        |> Seq.map (fun (longIdent, symbolUses) ->
  +            match longIdent with
  +            | Some _ ->
  +                (* Find all longest SymbolUses which has unique roots. For example:
                              
  -                           module Top
  -                           module M =
  -                               type System.IO.Path with
  -                                   member static ExtensionMethod() = ()
  -
  -                           open M
  -                           open System
  -                           let _ = IO.Path.ExtensionMethod()
  -
  -                           The last line contains three SymbolUses: "System.IO", "System.IO.Path" and "Top.M.ExtensionMethod". 
  -                           So, we filter out "System.IO" since it's a prefix of "System.IO.Path".
  -
  -                        *)
  -                        let res =
  +                    module Top
  +                    module M =
  +                        type System.IO.Path with
  +                            member static ExtensionMethod() = ()
  +
  +                    open M
  +                    open System
  +                    let _ = IO.Path.ExtensionMethod()
  +
  +                    The last line contains three SymbolUses: "System.IO", "System.IO.Path" and "Top.M.ExtensionMethod". 
  +                    So, we filter out "System.IO" since it's a prefix of "System.IO.Path".
  +
  +                *)
  +                let res =
  +                    symbolUses
  +                    |> Seq.filter (fun nextSymbolUse ->
  +                        let res = 
                               symbolUses
  -                            |> Seq.filter (fun (nextSymbolUse, _) ->
  -                                let res = 
  -                                    symbolUses
  -                                    |> Seq.exists (fun (sUse, _) -> 
  -                                        nextSymbolUse <> sUse
  -                                        && (sUse.FullNames.Value |> Array.exists (fun fullName ->
  -                                            nextSymbolUse.FullNames.Value |> Array.exists (fun nextSymbolFullName ->
  -                                            fullName.Length > nextSymbolFullName.Length
  -                                            && fullName |> Array.startsWith nextSymbolFullName))))
  -                                    |> not
  -                                res)
  -                            |> Seq.toArray
  -                            |> Array.toSeq
  -                        res
  -                    | None -> symbolUses)
  -                |> Seq.map (Seq.map fst)
  -                |> Seq.concat
  +                            |> Seq.exists (fun sUse -> 
  +                                nextSymbolUse <> sUse
  +                                && (sUse.FullNames.Value |> Array.exists (fun fullName ->
  +                                    nextSymbolUse.FullNames.Value |> Array.exists (fun nextSymbolFullName ->
  +                                    fullName.Length > nextSymbolFullName.Length
  +                                    && fullName |> Array.startsWith nextSymbolFullName))))
  +                            |> not
  +                        res)
  +                    |> Seq.toArray
  +                    |> Array.toSeq
  +                res
               | None -> symbolUses)
           |> Seq.concat
           |> Seq.toArray
  
positive.code: open Microsoft.FSharp.Compiler.Ast
  open Microsoft.FSharp.Compiler.SourceCodeServices
  open FSharpVSPowerTools
  
  [<RequireQualifiedAccess>]
  type Category =
  
negative.code:         { from with StartCol = what.EndCol + 1 } // the dot between parts
      else from
  
  let getLongIdents (input: ParsedInput) : IDictionary<Range.pos, Idents> =
      let identsByEndPos = Dictionary<Range.pos, Idents>()
      
      let addLongIdentWithDots (LongIdentWithDots (longIdent, lids) as value) = 
          match longIdentToArray longIdent with
          | [||] -> ()
          | [|_|] as idents -> identsByEndPos.[value.Range.End] <- idents
          | idents ->
              for dotRange in lids do 
                  identsByEndPos.[Range.mkPos dotRange.EndLine (dotRange.EndColumn - 1)] <- idents
      
      let addIdent (ident: Ident) = 
          identsByEndPos.[ident.idRange.End] <- [|ident.idText|]
  
      let (|ConstructorPats|) = function
          | Pats ps -> ps
  