anchor.diff:      let tagsChanged = Event<_,_>()
       let mutable ranges : SnapshotSpan [] = [||]
   
  -    let triggerUpdate newRanges =
  -        let snapshot = buffer.CurrentSnapshot
  +    let triggerUpdate snapshot newRanges =
           ranges <- Array.map (fun x -> SnapshotSpan.OfRange(snapshot, x)) newRanges
  -
           tagsChanged.Trigger(
               self,
               SnapshotSpanEventArgs(
  
positive.code:         | _ -> ()
      }
  
  type SnapshotSpan with
      static member OfRange(snapshot: ITextSnapshot, r: range) =
          let sstart =
              snapshot
                  .GetLineFromLineNumber(r.StartLine - 1)
                  .Start.Add(r.StartColumn)
  
          let send =
              snapshot
                  .GetLineFromLineNumber(r.EndLine - 1).Start
                  .Add(r.EndColumn - 1)
  
          SnapshotSpan(sstart, send)
  
  type Tagger
      ( buffer: ITextBuffer
  
negative.code:             })
  
      let getTags (nssc: NormalizedSnapshotSpanCollection) =
          if Seq.isEmpty nssc || Array.isEmpty ranges then Seq.empty
          else
              let newSnapshot = (Seq.head nssc).Snapshot
              if newSnapshot.Version <> ranges.[0].Snapshot.Version then
                  ranges <- ranges |> Array.map (fun x -> x.TranslateTo(newSnapshot, SpanTrackingMode.EdgeExclusive))
              ranges
              |> Seq.filter nssc.IntersectsWith
              |> Seq.map (createTagSpan)
              |> Seq.cast<ITagSpan<_>>
  
      let mutable cts = new CancellationTokenSource()
  
      let doUpdate () =
          let uiContext = SynchronizationContext.Current
          let worker =
              asyncMaybe {
                  let dte = serviceProvider.GetService<EnvDTE.DTE, SDTE>()
                  let snapshot = buffer.CurrentSnapshot
                  let source = snapshot.GetText()
                  let! doc = dte.GetCurrentDocument(textDocument.FilePath)
                  let! project = projectFactory.CreateForDocument buffer doc
                  let! parseFileResults = languageService.ParseFileInProject (doc.FullName, source, project) |> Async.map Some
                  let! ast = parseFileResults.ParseTree
                  let ranges =
                      ast
                      |> visitAst 
                      |> Seq.filter (fun r -> r.StartLine <> r.EndLine)
                      |> Array.ofSeq
                  return (snapshot, ranges)
              } |> Async.bind (fun x -> async {
                   do! Async.SwitchToContext uiContext
                   match x with
                   | Some(snapshot, r) -> triggerUpdate snapshot r
                   | None -> ()
              })
  
          cts.Dispose()
          cts <- new CancellationTokenSource()
          Async.StartInThreadPoolSafe(worker, cts.Token)
  
      let docEventListener =
          new DocumentEventListener(
              [ViewChange.bufferEvent buffer],
              200us,
              doUpdate)
  
      do
          doUpdate ()
  
      interface ITagger<IOutliningRegionTag> with
  
  