anchor.diff:  
       let classificationChanged = Event<_,_>()
       let state = Atom None
  -    let mutable isWorking = false
  -
  +    let cancellationToken = Atom None
  +    
       let getProject() =
           maybe {
               let dte = serviceProvider.GetService<EnvDTE.DTE, SDTE>()
  
positive.code: 
  type SyntaxConstructClassifier (doc: ITextDocument, classificationRegistry: IClassificationTypeRegistryService,
                                  vsLanguageService: VSLanguageService, serviceProvider: IServiceProvider,
                                  projectFactory: ProjectFactory) as self = 
      
      let getClassficationType cat =
          match cat with
  
negative.code:             return! projectFactory.CreateForFileInProject doc.TextBuffer doc.FilePath projectItem.ContainingProject }
  
      let updateSyntaxConstructClassifiers force =
          let cancelToken = new CancellationTokenSource() 
          cancellationToken.Swap (fun _ -> Some (cancelToken))
          |> Option.iter (fun oldToken -> 
              oldToken.Cancel()
              oldToken.Dispose())
  
          let snapshot = doc.TextBuffer.CurrentSnapshot
          let currentState = state.Value
          let needUpdate =
              match force, currentState with
              | true, _ -> true
              | _, None -> true
              | _, Some state -> state.SnapshotSpan.Snapshot <> snapshot
                   
          if needUpdate then
              match getProject() with
              | Some project ->
                  debug "[SyntaxConstructClassifier] - Effective update"
                  let worker = 
                      async {
                          try
                              let! allSymbolsUses, lexer =
                                  vsLanguageService.GetAllUsesOfAllSymbolsInFile (snapshot, doc.FilePath, project, AllowStaleResults.No)
                              let! parseResults = vsLanguageService.ParseFileInProject(doc.FilePath, snapshot.GetText(), project)
  
                              let spans = 
  