anchor.diff:              member x.Invoke() = fullyQualifySymbol snapshotSpan fullSymbolName
           }
   
  -    let getSmartTagActions snapshotSpan candidates _symbol line col =
  +    let getSmartTagActions snapshotSpan candidates line col =
           let openNamespaceActions = 
               candidates
  -            |> List.map (fun e -> e.Namespace) 
  +            |> List.choose (fun e -> e.Namespace) 
               |> List.map (openNamespaceAction snapshotSpan line col)
               
           let qualifySymbolActions =
               candidates
               |> List.map (fun e -> 
                   match e.Namespace with
  -                | "" -> e.Name
  -                | ns -> ns + "." + e.Name)
  +                | None -> e.Name
  +                | Some ns -> ns + "." + e.Name)
               |> List.map (qualifySymbolAction snapshotSpan)
               
           let actions = openNamespaceActions @ qualifySymbolActions |> Seq.toReadOnlyCollection
  
positive.code:                             | Some _ -> return! liftMaybe None
                              | None ->
                                  let! entities = vsLanguageService.GetAllEntities (doc.FullName, newWord.Snapshot.GetText(), project)
                                  let entitiesNames =
                                      entities 
                                      |> Seq.map (fun e ->
                                          try e.FullName 
                                          with _ -> e.DisplayName)
                                      |> Seq.choose (fun name -> 
                                          match name.LastIndexOf '.' with
                                          | -1 -> 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
  
                                  let! checkResults = 
                                      vsLanguageService.ParseFileInProject (doc.FullName, newWord.Snapshot.GetText(), project) |> liftAsync
  
                                  return! 
                                      checkResults.ParseTree 
                                      |> Option.map (fun tree ->
                                          let line, column = 
                                              match Ast.findNearestOpenStatementBlock (codeGenService.ExtractFSharpPos point) tree with
                                              | Some pos -> pos.Line, pos.Column
                                              | None -> 1, 1
                                          sym, entitiesNames, line, column)
                                      |> liftMaybe
                      }
                      |> Async.map (fun result -> 
                          state <- result
                          let span = SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)
                          tagsChanged.Trigger(self, SnapshotSpanEventArgs(span)))
                      |> Async.StartImmediateSafe
                      currentWord <- Some newWord
              | _ -> ()
  
      let docEventListener = new DocumentEventListener ([ViewChange.layoutEvent view; ViewChange.caretEvent view], 
                                                        500us, updateAtCaretPosition)
  
negative.code:           
      let tagsChanged = Event<_, _>()
      let mutable currentWord: SnapshotSpan option = None
      let mutable state: (Entity list * int * int) option = None 
  
      let triggerTagsChanged() =
          let span = SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)
          tagsChanged.Trigger(self, SnapshotSpanEventArgs(span))
  
      let updateAtCaretPosition() =
          match buffer.GetSnapshotPoint view.Caret.Position, currentWord with
  