anchor.diff:      let shouldImplementInterface _interfaceState (entity: FSharpEntity) =
           not (InterfaceStubGenerator.hasNoInterfaceMember entity)
   
  -    let handleImplementInterface (span: SnapshotSpan) state displayContext implementedMemberSignatures entity = 
  +    let handleImplementInterface (snapshot: ITextSnapshot) state displayContext implementedMemberSignatures entity = 
           let editorOptions = editorOptionsFactory.GetOptions(buffer)
           let indentSize = editorOptions.GetOptionValue((IndentSize()).Key)
           let startColumn = inferStartColumn indentSize state
  
positive.code:     let updateAtCaretPosition() =
          asyncMaybe {
              let! point = buffer.GetSnapshotPoint view.Caret.Position |> liftMaybe
              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! 
                      (if (fsSymbolUse.Symbol :? FSharpEntity) && point.InSpan newWord then
                          let entity = fsSymbolUse.Symbol :?> FSharpEntity
                          // 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
                       else None) |> liftMaybe
              | _ -> return! (liftMaybe None)
          }
          |> Async.map (fun res -> 
              let changed =
                  match state, res with
                  | None, None -> false
                  | _ -> true
              state <- res
              if changed then
                  let span = SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)
                  tagsChanged.Trigger(self, SnapshotSpanEventArgs(span)))
  
negative.code:             use transaction = textUndoHistory.CreateTransaction("Implement Interface Explicitly")
              match state.EndPosOfWith with
              | Some pos -> 
                  let currentPos = snapshot.GetLineFromLineNumber(pos.Line-1).Start.Position + pos.Column
                  buffer.Insert(currentPos, stub + new String(' ', startColumn)) |> ignore
              | None ->
                  let range = state.InterfaceData.Range
                  let currentPos = snapshot.GetLineFromLineNumber(range.EndLine-1).Start.Position + range.EndColumn
                  buffer.Insert(currentPos, " with") |> ignore
                  buffer.Insert(currentPos + 5, stub + new String(' ', startColumn)) |> ignore
              transaction.Complete()
  
      let implementInterface snapshot (state: InterfaceState, displayContext, entity, results: ParseAndCheckResults) =
          { new ISmartTagAction with
              member x.ActionSets = null
              member x.DisplayText = "Implement Interface Explicitly"
  