anchor.diff:               | _ -> None)
               |> Option.map (fun (fullNames, declaringEntity) ->
                    [| for name in fullNames do
  -                      let partNamespace = getPartNamespace fullIsland name
  +                      let partNamespace = getNamespaceInUse fullIsland name
                         yield partNamespace
  -                    yield! entityNamespace declaringEntity |])
  +                    yield! 
  +                        entityNamespace declaringEntity
  +                        |> List.map (Option.bind (getNamespaceInUse qualifyingIsland))
  +                 |])
               |> Option.toArray
               |> Array.concat
               |> Array.choose id
  -            |> set
  -        | None -> Set.empty
  +            |> Array.distinct
   
       type SymbolUseWithFullNames =
           { SymbolUse: FSharpSymbolUse
  
positive.code: 
      type NamespaceUse =
          { Ident: string
            SymbolLocation: range }
      
      let getPartNamespace (fullIsland: string) (fullName: string) =
          // given a full island such as `Text.ISegment` and a full name of `MonoDevelop.Core.Text.ISegment`, return `MonoDevelop.Core`
          let lengthDiff = fullName.Length - fullIsland.Length - 2
          if lengthDiff <= 0 || lengthDiff > fullName.Length - 1 then None
          else Some fullName.[0..lengthDiff]
  
      let getPossibleNamespaces (getSourceLineStr: int -> string) (symbolUse: FSharpSymbolUse) : Set<string> =
          let lineStr = getSourceLineStr symbolUse.RangeAlternate.StartLine
          match QuickParse.GetCompleteIdentifierIsland true lineStr symbolUse.RangeAlternate.EndColumn with
          | Some(fullIsland, _, _) ->
              let isQualified fullName = fullName = fullIsland
  
              (match symbolUse with
  
negative.code: 
      type SymbolUse =
          { SymbolUse: FSharpSymbolUse
            PossibleNamespaces: NamespaceUse[] }
  
      let getSymbolUses (getSourceLineStr: int -> string) (symbolUses: FSharpSymbolUse[]) : SymbolUse[] =
          symbolUses
          |> Array.filter (fun (symbolUse: FSharpSymbolUse) -> 
               not symbolUse.IsFromDefinition //&& 
               //match symbolUse.Symbol with
               //| :? FSharpEntity as e -> not e.IsNamespace
               //| _ -> true
             )
          |> Array.map (fun su ->
              { SymbolUse = su
  