anchor.diff:                                  let entitiesNames =
                                       entities 
                                       |> Seq.map (fun e -> try e.FullName with _ -> e.DisplayName)
  -                                    |> Seq.filter (fun name -> name.EndsWith sym.Text)
  -                                    //|> Seq.truncate 5
  +                                    |> Seq.choose (fun name -> 
  +                                        match name.LastIndexOf '.' with
  +                                        | -1 -> 
  +                                            if name = sym.Text then Some { Namespace = ""; Name = name } else None
  +                                        | lastDotIndex -> 
  +                                            let lastIdent = name.Substring (lastDotIndex + 1)
  +                                            if lastIdent = sym.Text then 
  +                                                Some { Namespace = name.Substring (0, lastDotIndex); Name = lastIdent }
  +                                            else None)
                                       |> Seq.toList
   
                                   return! Some (sym, entitiesNames) |> liftMaybe
  
positive.code: type ResolveUnopenedNamespaceSmartTag(actionSets) =
      inherit SmartTag(SmartTagType.Factoid, actionSets)
  
  type ResolveUnopenedNamespaceSmartTagger
           (view: ITextView, buffer: ITextBuffer, textUndoHistory: ITextUndoHistory,
            vsLanguageService: VSLanguageService, serviceProvider: IServiceProvider,
  
negative.code:     let docEventListener = new DocumentEventListener ([ViewChange.layoutEvent view; ViewChange.caretEvent view], 
                                                        500us, updateAtCaretPosition)
  
      let openNamespace (_snapshot: SnapshotSpan) _ns = 
          use transaction = textUndoHistory.CreateTransaction(Resource.recordGenerationCommandName)
          //let currentLine = snapshot.GetLineFromLineNumber(insertionPos.InsertionPos.Line-1).Start.Position + insertionPos.InsertionPos.Column
          //buffer.Insert(currentLine, stub) |> ignore
          transaction.Complete()
  
      let fullyQualifySymbol (snapshotSpan: SnapshotSpan) fullSymbolName = 
          use transaction = textUndoHistory.CreateTransaction(Resource.recordGenerationCommandName)
          //let currentLine = snapshot.GetLineFromLineNumber(insertionPos.InsertionPos.Line-1).Start.Position + insertionPos.InsertionPos.Column
          //buffer.Insert(currentLine, stub) |> ignore
          snapshotSpan.Snapshot.TextBuffer.Replace (snapshotSpan.Span, fullSymbolName) |> ignore
          transaction.Complete()
  
      let openNamespaceAction snapshot ns =
          { new ISmartTagAction with
              member x.ActionSets = null
              member x.DisplayText = "open " + ns
              member x.Icon = null
              member x.IsEnabled = true
              member x.Invoke() = openNamespace snapshot ns
          }
  
      let qualifySymbolAction snapshotSpan fullSymbolName =
          { new ISmartTagAction with
              member x.ActionSets = null
              member x.DisplayText = fullSymbolName
              member x.Icon = null
              member x.IsEnabled = true
              member x.Invoke() = fullyQualifySymbol snapshotSpan fullSymbolName
          }
  
      let getSmartTagActions snapshotSpan candidates _symbol =
          let openNamespaceActions = 
              candidates
              |> List.map (fun e -> e.Namespace) 
              |> List.map (openNamespaceAction snapshotSpan)
              
          let qualifySymbolActions =
              candidates
              |> List.map (fun e -> 
                  match e.Namespace with
                  | "" -> e.Name
                  | ns -> ns + "." + e.Name)
              |> List.map (qualifySymbolAction snapshotSpan)
              
          let actions = openNamespaceActions @ qualifySymbolActions |> Seq.toReadOnlyCollection
  
          [ SmartTagActionSet(actions) ] |> Seq.toReadOnlyCollection
  
      interface ITagger<ResolveUnopenedNamespaceSmartTag> with
          member x.GetTags _spans =
  