anchor.diff:               
       let (beginLine, beginCol) =
           if endCol >=lastIdentAtLoc.Length && (beginLine <> endLine || (endCol-beginCol) >= lastIdentAtLoc.Length) then 
  -            (endLine,endCol-lastIdentAtLoc.Length)
  +          (endLine,endCol-lastIdentAtLoc.Length)
           else
  -            (beginLine, beginCol)
  +          (beginLine, beginCol)
       Range.mkPos beginLine beginCol, Range.mkPos endLine endCol
       //(beginLine, beginCol), (endLine, endCol)
   
  
positive.code:     | _ -> None
  
    member x.GetTypedParseResultWithTimeout(projectFilename, fileName:string, src, stale, ?timeout) = 
     async {
      let fileName = if Path.GetExtension fileName = ".sketchfs" then Path.ChangeExtension (fileName, ".fsx") else fileName
      let opts = x.GetCheckerOptions(fileName, projectFilename, src)
      Debug.WriteLine(sprintf "LanguageService: GetTypedParseResultWithTimeout, fileName=%s" fileName)
      // Try to get recent results from the F# service
      match x.TryGetStaleTypedParseResult(fileName, opts, src, stale) with
      | Some _ as results ->
          Debug.WriteLine("LanguageService: GetTypedParseResultWithTimeout: using stale results")
          return results
      | None -> 
          Debug.WriteLine("LanguageService: GetTypedParseResultWithTimeout: No stale results - trying typecheck with timeout")
          // 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 -> return mbox.TryPostAndReply((fun reply -> (fileName, src, opts, reply)), timeout = timeout)
          | None -> return mbox.TryPostAndReply((fun reply -> (fileName, src, opts, reply)))
     }
  
    /// Returns a TypeParsedResults if available, otherwise None
    member x.GetTypedParseResultIfAvailable(projectFilename, fileName:string, src, stale) = 
  
negative.code: 
      member x.GetAllUsesOfAllSymbolsInFile() =
        async {
          match infoOpt with
          | None -> return None
          | Some (checkResults, _parseResults) ->
              let! allSymbols = checkResults.GetAllUsesOfAllSymbolsInFile()
              return Some allSymbols
        }
  
      member x.PartialAssemblySignature =
        async {
          match infoOpt with
          | None -> return None
          | Some (checkResults, _parseResults) ->
            return Some checkResults.PartialAssemblySignature
        }
  
      member x.GetErrors() =
        match infoOpt with 
        | None -> None
        | Some (checkResults, _parseResults) -> Some checkResults.Errors
  
      member x.GetNavigationItems() =
        match infoOpt with 
        | None -> [| |]
        | Some (_checkResults, parseResults) -> 
           // GetNavigationItems is not 100% solid and throws occasional exceptions
            try parseResults.GetNavigationItems().Declarations
            with _ -> 
              Debug.Assert(false, "couldn't update navigation items, ignoring")  
              [| |]
  
      member x.ParseTree = 
        match infoOpt with
        | Some (_checkResults,parseResults) -> parseResults.ParseTree
        | None -> None
  
      member x.CheckResults = 
        match infoOpt with
        | Some (checkResults,_parseResults) -> checkResults |> Some
        | None -> None
  
      member x.GetExtraColorizations() =
        match infoOpt with
        | Some(checkResults,_parseResults) -> checkResults.GetExtraColorizationsAlternate() |> Some
        | None -> None
  
  [<RequireQualifiedAccess>]
  type AllowStaleResults = 
    // Allow checker results where the source doesn't even match
    | MatchingFileName
    // Allow checker results where the source matches but where the background builder may not have caught up yet after some other change
    | MatchingSource
    // Don't allow stale results
    | No
  
  type Debug = System.Console
  
  /// Provides functionality for working with the F# interactive checker running in background
  type LanguageService(dirtyNotify) =
  