anchor.diff:    let byPattern (cache:Dictionary<_,_>) pattern symbols =
   
       let matchName (matcher:StringMatcher) (name:string) =
  -      match name with
  -      | null -> SearchCategory.MatchResult(false, -1)
  -      | name ->
  -      match cache.TryGetValue(name) with
  -      | true, v -> v
  -      | false, _ ->
  -        let doesMatch, rank = matcher.CalcMatchRank (name)
  -        let savedMatch = SearchCategory.MatchResult (doesMatch, rank)
  -        cache.Add(name, savedMatch)
  -        savedMatch
  +      if name = null then (false, -1)
  +      else
  +        match cache.TryGetValue(name) with
  +        | true, v -> v
  +        | false, _ ->
  +          let doesMatch, rank = matcher.CalcMatchRank (name)
  +          let savedMatch = (doesMatch, rank)
  +          cache.Add(name, savedMatch)
  +          savedMatch
   
       let matcher = StringMatcher.GetMatcher (pattern, false)
   
       symbols
  -    |> Seq.choose (fun s -> let matchres = matchName matcher (correctDisplayName s)
  -                            if matchres.Match then Some(s, matchres.Rank)
  +    |> Seq.choose (fun s -> let doesMatch, rank = matchName matcher (correctDisplayName s)
  +                            if doesMatch then Some(s, rank)
                               else None)
   
   type SymbolSearchResult(match', matchedString, rank, symbol:FSharpSymbolUse) =
  
positive.code:                          callback.ReportResult sr
  
                       with ex -> 
                        LoggingService.LogError("F# Global Serach error", ex) } |> Async.StartImmediate) , token )
  
  
negative.code:     elif accessibility.IsInternal then getImage inter
      else getImage priv 
  
  module Search = 
      
    let private filter tag (s:FSharpSymbolUse seq) =
      match tag with
      | "type" | "t" | "c" -> s |> Seq.choose ((|Constructor|_|) >> Option.cast)
      | "mod" -> s |> Seq.choose ((|Module|_|) >> Option.cast)
      | "s" ->   s |> Seq.choose ((|ValueType|_|) >> Option.cast)
      | "i" ->   s |> Seq.choose ((|Interface|_|) >> Option.cast)
      | "e" ->   s |> Seq.choose ((|Enum|_|) >> Option.cast)
      | "d" ->   s |> Seq.choose ((|Delegate|_|) >> Option.cast)
      | "u" ->   s |> Seq.choose ((|Union|_|) >> Option.cast)
      | "r" ->   s |> Seq.choose ((|Record|_|) >> Option.cast)
      | "member" | "m" -> s |> Seq.choose ((|Method|_|) >> Option.cast)
      | "p" ->   s |> Seq.choose ((|Property|_|) >> Option.cast)
      | "f" ->   s |> Seq.choose ((|Field|_|) >> Option.cast)
      | "ap" ->  s |> Seq.choose ((|ActivePattern|_|) >> Option.cast)
      | "op" ->  s |> Seq.choose ((|Operator|_|) >> Option.cast)
      | _ ->     s
  
    let byTag tag (items: FSharpSymbolUse seq) =
  