anchor.diff:        EndPosOfWith: pos option
         Tokens: TokenInformation list }
   
  -/// This tagger will provide tags for every word in the buffer that
  -/// matches the word currently under the cursor.
   type ImplementInterfaceSmartTagger(view: ITextView, buffer: ITextBuffer, 
                                      editorOptionsFactory: IEditorOptionsFactoryService, textUndoHistory: ITextUndoHistory,
                                      vsLanguageService: VSLanguageService, serviceProvider: IServiceProvider) as self =
       let tagsChanged = Event<_, _>()
  +    let mutable currentWord = None
       let mutable state = None
   
       let queryInterfaceState (point: SnapshotPoint) (doc: EnvDTE.Document) (project: IProjectProvider) =
  
positive.code:     let shouldImplementInterface _interfaceState (entity: FSharpEntity) =
          not (InterfaceStubGenerator.hasNoInterfaceMember entity)
  
      let handleImplementInterface (span: SnapshotSpan) state displayContext implementedMemberSignatures entity = 
          let editorOptions = editorOptionsFactory.GetOptions(buffer)
          let indentSize = editorOptions.GetOptionValue((IndentSize()).Key)
          let startColumn = inferStartColumn indentSize state
  
negative.code:     let updateAtCaretPosition() =
          asyncMaybe {
              let! point = buffer.GetSnapshotPoint view.Caret.Position |> liftMaybe
              match currentWord with
              | Some word when point.InSpan word -> 
                  return! liftMaybe state
              | _ ->
                  let dte = serviceProvider.GetService<EnvDTE.DTE, SDTE>()
                  let! doc = dte.GetActiveDocument() |> liftMaybe
                  let! project = ProjectProvider.createForDocument doc |> liftMaybe
                  let! newWord, symbol = vsLanguageService.GetSymbol(point, project) |> liftMaybe
                  match symbol.Kind with
                  | SymbolKind.Ident ->
                      let! interfaceState = queryInterfaceState point doc project
                      let! (fsSymbolUse, results) = 
                          vsLanguageService.GetFSharpSymbolUse (newWord, symbol, doc.FullName, project, AllowStaleResults.MatchingSource)
                      // Recheck cursor position to ensure it's still in new word
                      let! point = buffer.GetSnapshotPoint view.Caret.Position |> liftMaybe
                      return!
                         (match fsSymbolUse.Symbol with
                          | :? FSharpEntity as entity when point.InSpan newWord ->
                              // The entity might correspond to another symbol so we check for symbol text and start ranges as well
                              if InterfaceStubGenerator.isInterface entity && entity.DisplayName = symbol.Text 
                                  && hasSameStartPos fsSymbolUse.RangeAlternate interfaceState.InterfaceData.Range then
                                  Some (newWord, (interfaceState, fsSymbolUse.DisplayContext, entity, results))
                              else None
                          | _ -> None) |> liftMaybe
                  | _ -> return! liftMaybe None
          }
          |> Async.map (fun result -> 
              let changed =
                  match state, result, currentWord with
                  | None, None, _ -> false
                  | _, Some (newWord, _), Some oldWord -> newWord <> oldWord
                  | _ -> true
              state <- result
              if changed then
                  let span = SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)
                  tagsChanged.Trigger(self, SnapshotSpanEventArgs(span)))
  