anchor.diff:          Span: Range01
           Description: string
       }
  +
  +module Index =
  +    open System.Globalization
  +    
  +    [<System.Diagnostics.DebuggerDisplay("{DebugString()}")>]
  +    type private IndexEntry(str: string, offset: int, item: Navigation.NavigableItem, isOperator: bool) =
  +        member x.String = str
  +        member x.Offset = offset
  +        member x.Length = str.Length - offset
  +        member x.Item = item
  +        member x.IsOperator = isOperator
  +        member x.StartsWith (s: string) = 
  +            if s.Length > x.Length then 
  +                false
  +            else
  +                CultureInfo.CurrentCulture.CompareInfo.IndexOf(str, s, offset, s.Length, CompareOptions.IgnoreCase) = offset
  +        member private x.DebugString() = sprintf "%s (offset %d) (%s)" (str.Substring offset) offset str
  +
  +    let private IndexEntryComparer =
  +        {
  +            new IComparer<IndexEntry> with
  +                member x.Compare(a, b) = 
  +                    CultureInfo.CurrentCulture.CompareInfo.Compare(a.String, a.Offset, b.String, b.Offset, CompareOptions.IgnoreCase)
  +        }
  +        
  +    type IIndexedNavigableItems =
  +        abstract Find: searchValue: string * itemProcessor: (Navigation.NavigableItem * string * bool * MatchKind-> unit) -> unit
  +
  +    type Builder() =
  +        let entries = ResizeArray()
  +
  +        member x.Add(items: seq<Navigation.NavigableItem>) =
  +            for item in items do
  +                let isOperator, name = 
  +                    if PrettyNaming.IsMangledOpName item.Name then 
  +                        true, PrettyNaming.DecompileOpName item.Name 
  +                    else 
  +                        false, item.Name
  +                for i = 0 to name.Length - 1 do
  +                    entries.Add(IndexEntry(name, i, item, isOperator))
  +
  +        member x.BuildIndex() =
  +            entries.Sort(IndexEntryComparer)
  +            {
  +                new IIndexedNavigableItems with
  +                    member x.Find(searchValue, processor) = 
  +                        let entryToFind = IndexEntry(searchValue, 0, Unchecked.defaultof<_>, Unchecked.defaultof<_>)
  +                        let mutable pos = entries.BinarySearch(entryToFind, IndexEntryComparer)
  +                        if pos < 0 then pos <- ~~~pos
  +                        while pos < entries.Count && entries.[pos].StartsWith searchValue do
  +                            let entry = entries.[pos]
  +                            let matchKind = 
  +                                if entry.Offset = 0 then
  +                                    if entry.Length = searchValue.Length then MatchKind.Exact
  +                                    else MatchKind.Prefix
  +                                else MatchKind.Substring
  +                            processor(entry.Item, entry.String, entry.IsOperator, matchKind)
  +                            pos <- pos + 1
  +            }
  +
   
   [<Package("f152487e-9a22-4cf9-bee6-a8f7c77f828d")>]
   [<Export(typeof<INavigateToItemProviderFactory>)>]
  
positive.code:             let projects = 
                  match listFSharpProjectsInSolution() with
                  | [] -> maybe {
                            let dte = serviceProvider.GetService<EnvDTE.DTE, Microsoft.VisualStudio.Shell.Interop.SDTE>()
                            let! doc = dte.GetActiveDocument()
                            return! ProjectProvider.createForDocument doc }
                            |> Option.toArray
                  | xs -> List.toArray xs
              runSearch(projects, openedDocuments, searchValue, callback, cts.Token)
          member x.StopSearch() = 
              cts.Cancel()
              cts <- new CancellationTokenSource()
  
      interface IDisposable with
          member x.Dispose() = (x :> INavigateToItemProvider).StopSearch()
  and
      [<Export>]
      NavigationItemIconCache() =
  
negative.code:             vsCompositionService.SatisfyImportsOnce(instance)
              |> ignore
              instance :> _
  
      interface INavigateToItemProviderFactory with
          member x.TryCreateNavigateToItemProvider(serviceProvider, provider) = 
  