anchor.diff:                        yield! entityNamespace declaringEntity ]
               } |> Option.toList |> List.concat |> List.choose id
   
  -        let namespacesInUse =
  +        let namespacesInUse : NamespaceUse list =
               symbolUses
  -            |> Seq.filter (fun (s: FSharpSymbolUse) -> not s.IsFromDefinition)
  -            |> Seq.collect getPossibleNamespaces
  -            |> Set.ofSeq
  -
  -        let filter list: (Set<string> * range) list =
  -            let rec filterInner acc list (seenNamespaces: Set<string>) = 
  -                let notUsed ns = not (namespacesInUse.Contains ns) || seenNamespaces.Contains ns
  +            |> Array.filter (fun (s: FSharpSymbolUse) -> not s.IsFromDefinition)
  +            |> Array.toList
  +            |> List.collect (fun x -> 
  +                getPossibleNamespaces x 
  +                |> List.distinct 
  +                |> List.map (fun ns -> { Ident = ns; Location = x.RangeAlternate }))
  +
  +        let filter list: OpenStatement list =
  +            let rec filterInner acc (list: OpenStatement list) (seenOpenStatements: OpenStatement list) = 
  +                
  +                let notUsed (os: OpenStatement) = 
  +                    not (namespacesInUse |> List.exists (fun nsu -> rangeContainsRange os.ModuleRange nsu.Location && os.Names |> Set.contains nsu.Ident))
  +                    || seenOpenStatements |> List.contains os
  +                
                   match list with 
  -                | (ns, range) :: xs when ns |> Set.forall notUsed -> 
  -                    filterInner ((ns, range) :: acc) xs (seenNamespaces |> Set.union ns)
  -                | (ns, _) :: xs ->
  -                    filterInner acc xs (seenNamespaces |> Set.union ns)
  +                | os :: xs when notUsed os -> 
  +                    filterInner (os :: acc) xs (os :: seenOpenStatements)
  +                | os :: xs ->
  +                    filterInner acc xs (os :: seenOpenStatements)
                   | [] -> List.rev acc
  -            filterInner [] list Set.empty
  -
  -        let openStatements = getOpenStatements parsedInput
  -        openStatements |> filter |> List.map snd
  +            
  +            filterInner [] list []
  +
  +        parsedInput |> getOpenStatements |> filter |> List.map (fun os -> os.Range)
   
   [<DiagnosticAnalyzer(FSharpConstants.FSharpLanguageName)>]
   type internal UnusedOpensDiagnosticAnalyzer() =
  
positive.code:     override __.SupportedDiagnostics = ImmutableArray.Create Descriptor
      override this.AnalyzeSyntaxAsync(_, _) = Task.FromResult ImmutableArray<Diagnostic>.Empty
  
      static member GetUnusedOpenRanges(document: Document, options, checker: FSharpChecker) =
          asyncMaybe {
              do! Option.guard Settings.CodeFixes.UnusedOpens
              let! sourceText = document.GetTextAsync()
  
negative.code:         | Some (island, _, _) -> island = fullName
          | None -> false
  
      type NamespaceUse =
          { Ident: string
            Location: range }
  
      let getUnusedOpens (sourceText: SourceText) (parsedInput: ParsedInput) (symbolUses: FSharpSymbolUse[]) : range list =
  
          let getPartNamespace (symbolUse: FSharpSymbolUse) (fullName: string) =
              // given a symbol range such as `Text.ISegment` and a full name of `MonoDevelop.Core.Text.ISegment`, return `MonoDevelop.Core`
  