anchor.diff:                return None
             | None ->
               LoggingService.LogDebug("LanguageService: GetTypedParseResultWithTimeout: No stale results - typechecking without timeout")
  -            let! result = x.ParseAndCheckFile(fileName, src, opts, obs) 
  +            let! result = x.ParseAndCheckFile(fileName, src, version, opts, obs) 
               return Some(result) }
   
     /// Returns a TypeParsedResults if available, otherwise None
     member x.GetTypedParseResultIfAvailable(projectFilename, fileName:string, src, stale) = 
       let opts = x.GetCheckerOptions(fileName, projectFilename, src)
       LoggingService.LogDebug("LanguageService: GetTypedParseResultIfAvailable: file={0}", Path.GetFileName(fileName))
  -    match x.TryGetStaleTypedParseResult(fileName, opts, src, stale)  with
  -    | Some results -> results
  -    | None -> ParseAndCheckResults.Empty
  +    x.TryGetStaleTypedParseResult(fileName, opts, src, stale)
   
     /// Get all the uses of a symbol in the given file (using 'source' as the source for the file)
  -  member x.GetUsesOfSymbolAtLocationInFile(projectFilename, fileName, source, line:int, col, lineStr) =
  +  member x.GetUsesOfSymbolAtLocationInFile(projectFilename, fileName, version, source, line:int, col, lineStr) =
       asyncMaybe {
         LoggingService.LogDebug("LanguageService: GetUsesOfSymbolAtLocationInFile: file:{0}, line:{1}, col:{2}", Path.GetFileName(fileName), line, col)
         let! colu, identIsland = Parsing.findLongIdents(col, lineStr) |> async.Return
  -      let! results = x.GetTypedParseResultWithTimeout(projectFilename, fileName, source, AllowStaleResults.MatchingSource)
  +      let! results = x.GetTypedParseResultWithTimeout(projectFilename, fileName, version, source, AllowStaleResults.MatchingSource)
         let! symbolUse = results.GetSymbolAtLocation(line, colu, lineStr)
         let lastIdent = Seq.last identIsland
         let! refs = results.GetUsesOfSymbolInFile(symbolUse.Symbol) |> Async.map Some
  
positive.code:       match stale with 
        | AllowStaleResults.MatchingFileName -> checker.TryGetRecentTypeCheckResultsForFile(fixFileName fileName, options) 
        | AllowStaleResults.MatchingSource -> checker.TryGetRecentTypeCheckResultsForFile(fixFileName fileName, options, source=src) 
        | AllowStaleResults.No -> None
      match res with 
      | Some (untyped,typed,_) when typed.HasFullTypeCheckInfo  -> Some (ParseAndCheckResults(typed, untyped))
      | _ -> None
  
    member internal x.ParseAndCheckFile (fileName, src, opts, obsoleteCheck) =
      async {
        try
           let fileName = fixFileName(fileName)
           let! parseResults, checkAnswer = checker.ParseAndCheckFileInProject(fileName, 0, src ,opts, obsoleteCheck, null )
  
           // Construct new typed parse result if the task succeeded
           let results =
  
negative.code:         LoggingService.LogDebug("LanguageService agent: Exception: {0}", exn.ToString())
          return ParseAndCheckResults.Empty }
  
    member x.ParseAndCheckFileInProject(projectFilename, fileName, version:int, src:string, obsoleteCheck) =
      let fileName = if Path.GetExtension fileName = ".sketchfs" then Path.ChangeExtension (fileName, ".fsx") else fileName
      let opts = x.GetCheckerOptions(fileName, projectFilename, src)
      x.ParseAndCheckFile(fileName, src, version, opts, obsoleteCheck) 
  
    /// Parses and checks the given file in the given project under the given configuration.
    ///Asynchronously returns the results of checking the file.
    member x.GetTypedParseResultWithTimeout(projectFilename, fileName, version:int, src:string, stale, ?timeout, ?obsoleteCheck) =
      let obs = defaultArg obsoleteCheck (IsResultObsolete(fun () -> false))
      async {
        let fileName = if Path.GetExtension fileName = ".sketchfs" then Path.ChangeExtension (fileName, ".fsx") else fileName
  