anchor.diff:          |> Async.Parallel
           |> Async.map Array.concat
         
  -      let filteredSymbols = allSymbolUses |> Array.filter predicate 
  -              
  +      let filteredSymbols = allSymbolUses |> Array.filter predicate     
         return filteredSymbols }
   
     member x.ParseAndCheckProject options =
       checker.ParseAndCheckProject(options)
  -                    
  -  member x.GetAllProjectDeclarations options =
  -    //clear cache on project change
  -    match symbolCache.TryGetValue options with
  +
  +  member x.GetCachedProjectCheckResult projectfile =
  +    //TODO clear cache on project invalidation
  +    //should we?  Or just wait for the checker to finish which will update it anyway.
  +    match checkProjectResultsCache.TryGetValue projectfile with
       | true, v -> Some v
       | false, _ -> None
  -           
  +
     /// This function is called when the project is know to have changed for reasons not encoded in the ProjectOptions
     /// e.g. dependent references have changed
     member x.InvalidateConfiguration(options) =
  
positive.code:           LoggingService.LogDebug("LanguageService: GetTypedParseResultWithTimeout: using stale results")
            return results
        | None -> 
            
            // If we didn't get a recent set of type checking results, we put in a request and wait for at most 'timeout' for a response
            match timeout with
            | Some timeout ->
  
negative.code: //type Debug = System.Console
  
  /// Provides functionality for working with the F# interactive checker running in background
  type LanguageService(dirtyNotify) as x =
  
    /// Load times used to reset type checking properly on script/project load/unload. It just has to be unique for each project load/reload.
    /// Not yet sure if this works for scripts.
    let fakeDateTimeRepresentingTimeLoaded proj = DateTime(abs (int64 (match proj with null -> 0 | _ -> proj.GetHashCode())) % 103231L)
    let checkProjectResultsCache = Collections.Generic.Dictionary<string, _>()
  
    let projectChecked filename =
      let computation =
        async {
           let displayname = Path.GetFileName filename
           LoggingService.LogDebug(sprintf "LanguageService: Project checked: %s" displayname)
           if checkProjectResultsCache.ContainsKey filename then
             LoggingService.LogDebug(sprintf "LanguageService: Removing project check results for: %s" displayname)
             checkProjectResultsCache.Remove(filename) |> ignore
             
           LoggingService.LogDebug(sprintf "LanguageService: Getting project checker options for: %s" displayname)
           let projOptions = x.GetProjectCheckerOptions(filename)
           
           LoggingService.LogDebug(sprintf "LanguageService: Getting CheckProjectResults for: %s" displayname)
           try
             let! (projCheck:FSharpCheckProjectResults) = x.ParseAndCheckProject(projOptions)
             if not projCheck.HasCriticalErrors then
               LoggingService.LogDebug(sprintf "LanguageService: Adding CheckProjectResults to cache for: %s" displayname)
               checkProjectResultsCache.Add(filename, projCheck) |> ignore
             else
               LoggingService.LogDebug(sprintf "LanguageService: NOT adding CheckProjectResults to cache for: %s due to critical errors" displayname)
           with exn ->
             LoggingService.LogDebug(sprintf "LanguageService: Error", exn) }
      Async.Start computation  
  
    // Create an instance of interactive checker. The callback is called by the F# compiler service
    // when its view of the prior-typechecking-state of the start of a file has changed, for example
  