anchor.diff:                  checkFileInProjectCachePossiblyStale.Clear ltok
                   checkFileInProjectCache.Clear ltok
                   parseFileCache.Clear(ltok))
  -            incrementalBuildersCache.Clear ctok
  +            incrementalBuildersCache.Clear(AssumeAnyCallerThreadWithoutEvidence())
               frameworkTcImportsCache.Clear ctok
               scriptClosureCacheLock.AcquireLock (fun ltok -> scriptClosureCache.Clear ltok)
               cancellable.Return ())
  
positive.code:             
      member bc.InvalidateConfiguration(options : FSharpProjectOptions, startBackgroundCompileIfAlreadySeen, userOpName) =
          let startBackgroundCompileIfAlreadySeen = defaultArg startBackgroundCompileIfAlreadySeen implicitlyStartBackgroundWork
          // This operation can't currently be cancelled nor awaited
          reactor.EnqueueOp(userOpName, "InvalidateConfiguration: Stamp(" + (options.Stamp |> Option.defaultValue 0L).ToString() + ")", options.ProjectFileName, fun ctok -> 
              // If there was a similar entry then re-establish an empty builder .  This is a somewhat arbitrary choice - it
              // will have the effect of releasing memory associated with the previous builder, but costs some time.
              if incrementalBuildersCache.ContainsSimilarKey (ctok, options) then
  
                  // We do not need to decrement here - the onDiscard function is called each time an entry is pushed out of the build cache,
                  // including by incrementalBuildersCache.Set.
                  let newBuilderInfo = CreateOneIncrementalBuilder (ctok, options, userOpName) |> Cancellable.runWithoutCancellation
                  incrementalBuildersCache.Set(ctok, options, newBuilderInfo)
  
                  // Start working on the project.  Also a somewhat arbitrary choice
                  if startBackgroundCompileIfAlreadySeen then 
                     bc.CheckProjectInBackground(options, userOpName + ".StartBackgroundCompile"))
  
      member bc.ClearCache(options : FSharpProjectOptions seq, userOpName) =
          // This operation can't currently be cancelled nor awaited
          reactor.EnqueueOp(userOpName, "ClearCache", String.Empty, fun ctok -> 
              options
              |> Seq.iter (fun options -> incrementalBuildersCache.RemoveAnySimilar(ctok, options)))
  
      member __.NotifyProjectCleaned (options : FSharpProjectOptions, userOpName) =
          reactor.EnqueueAndAwaitOpAsync(userOpName, "NotifyProjectCleaned", options.ProjectFileName, fun ctok -> 
           cancellable {
              // If there was a similar entry (as there normally will have been) then re-establish an empty builder .  This 
              // is a somewhat arbitrary choice - it will have the effect of releasing memory associated with the previous 
              // builder, but costs some time.
              if incrementalBuildersCache.ContainsSimilarKey (ctok, options) then
                  // We do not need to decrement here - the onDiscard function is called each time an entry is pushed out of the build cache,
                  // including by incrementalBuildersCache.Set.
                  let! newBuilderInfo = CreateOneIncrementalBuilder (ctok, options, userOpName) 
                  incrementalBuildersCache.Set(ctok, options, newBuilderInfo)
            })
  
      member __.CheckProjectInBackground (options, userOpName) =
          reactor.SetBackgroundOp (Some (userOpName, "CheckProjectInBackground", options.ProjectFileName, (fun ctok ct -> 
  
negative.code: 
      /// Clear the internal cache of the given projects.
      member __.ClearCache(options: FSharpProjectOptions seq, ?userOpName: string) =
          let _userOpName = defaultArg userOpName "Unknown"
          backgroundCompiler.ClearCache(options)
  
      /// This function is called when a project has been cleaned, and thus type providers should be refreshed.
      member __.NotifyProjectCleaned(options: FSharpProjectOptions, ?userOpName: string) =
  