anchor.diff:      override __.SupportedDiagnostics = ImmutableArray.Create Descriptor
       override this.AnalyzeSyntaxAsync(_, _) = Task.FromResult ImmutableArray<Diagnostic>.Empty
   
  -    static member GetUnusedOpenRanges(document: Document, options, checker: FSharpChecker) =
  +    static member GetUnusedOpenRanges(document: Document, options, checker: FSharpChecker) : Async<Option<range list>> =
           asyncMaybe {
               do! Option.guard Settings.CodeFixes.UnusedOpens
               let! sourceText = document.GetTextAsync()
  
positive.code:                       yield! entityNamespace declaringEntity ]
              } |> Option.toList |> List.concat |> List.choose id
  
          let namespacesInUse =
              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
                  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)
                  | [] -> List.rev acc
              filterInner [] list Set.empty
  
          let openStatements = getOpenStatements parsedInput
          openStatements |> filter |> List.map snd
  
  [<DiagnosticAnalyzer(FSharpConstants.FSharpLanguageName)>]
  type internal UnusedOpensDiagnosticAnalyzer() =
  
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`
  