anchor.diff:                      let! parseResults = pf.TimeAsync "ParseFileInProject" <| fun _ ->
                           vsLanguageService.ParseFileInProject(textDocument.FilePath, snapshot.GetText(), currentProject)
   
  -                    let includeUnusedOpens = 
  -                        includeUnusedOpens 
  -                        && not (isSignatureExtension(Path.GetExtension(textDocument.FilePath)) 
  -                        && currentProject.IsForStandaloneScript)
  -
                       let lexer = vsLanguageService.CreateLexer(snapshot, currentProject.CompilerOptions)
   
  -                    let! allSymbolsUses = pf.TimeAsync "GetAllUsesOfAllSymbolsInFile [NO UNUSED]" <| fun _ ->
  +                    let! allSymbolsUses = pf.TimeAsync "GetAllUsesOfAllSymbolsInFile" <| fun _ ->
                           vsLanguageService.GetAllUsesOfAllSymbolsInFile(
  -                            snapshot, textDocument.FilePath, currentProject, AllowStaleResults.No, includeUnusedOpens, pf)
  +                            snapshot, textDocument.FilePath, currentProject, AllowStaleResults.No, false, pf)
   
                       let getTextLineOneBased i = snapshot.GetLineFromLineNumber(i).GetText()
   
  -                    let! entitiesMap, openDeclarations = 
  -                        if includeUnusedOpens then
  -                            getOpenDeclarations (snapshot.GetText()) currentProject parseResults.ParseTree getTextLineOneBased pf
  -                        else async { return None, [] }
  -                      
  -                    let spans = pf.Time "getCategoriesAndLocations [FAST STAGE]" <| fun _ ->
  -                        getCategoriesAndLocations (allSymbolsUses, parseResults.ParseTree, lexer, getTextLineOneBased, openDeclarations, entitiesMap)
  +                    let spans = pf.Time "getCategoriesAndLocations" <| fun _ ->
  +                        getCategoriesAndLocations (allSymbolsUses, parseResults.ParseTree, lexer, getTextLineOneBased, [], None)
                           |> Array.sortBy (fun { WordSpan = { Line = line }} -> line)
   
                       let spans = 
  
positive.code:     interface IDisposable with
          member __.Dispose() = 
              events |> Option.iter (fun e -> e.BuildEvents.remove_OnBuildProjConfigDone onBuildDoneHandler)
              cancellationToken.Value
              |> Option.iter (fun token -> 
                  token.Cancel()
                  token.Dispose())
  
negative.code: [<NoComparison>]
  type private SlowStageData =
      { Snapshot: ITextSnapshot 
        UnusedSpans: Map<WordSpan, CategorizedColumnSpan>
        IsUpdating: bool }
  
  [<NoComparison>]
  type private SlowStage =
      | NoData of isUpdating: bool
      | Data of SlowStageData
  
  type SyntaxConstructClassifier
  