anchor.diff:          let proj = parseOptions.Project
   
           let doc = MonoDevelop.tryGetVisibleDocument fileName
  -
  +       
           if doc.IsNone || not (MDLanguageService.SupportedFileName (fileName)) then null else
   
           let shortFilename = Path.GetFileName fileName
           LoggingService.LogDebug ("FSharpParser: Parse starting on {0}", shortFilename)
   
  -        let isObsolete filename version cancellationRequested =
  +        let isObsolete filename version (token:CancellationToken) =
             SourceCodeServices.IsResultObsolete(fun () ->
               let shortFilename = Path.GetFileName filename
               try
  -              if not cancellationRequested then
  +              if not token.IsCancellationRequested then
                   match MonoDevelop.tryGetVisibleDocument filename with
                   | Some doc ->
                     let newVersion = doc.Editor.Version
  
positive.code: 
          Async.StartAsTask(
              cancellationToken = cancellationToken,
              computation = async {
  
              let parsedDoc = async {                    
                match tryGetFilePath fileName proj with
                | Some filePath -> 
                    LoggingService.LogDebug ("FSharpParser: Running ParseAndCheckFileInProject for {0}", shortFilename)
                    let projectFile = proj |> function null -> filePath | proj -> proj.FileName.ToString()
                    let obsolete = isObsolete parseOptions.FileName parseOptions.Content.Version cancellationToken.IsCancellationRequested
                    let! results = languageService.ParseAndCheckFileInProject(projectFile, filePath, 0, content.Text, obsolete)
                    //if you ever want to see the current parse tree
                    //let pt = match results.ParseTree with Some pt -> sprintf "%A" pt | _ -> "" 
                    LoggingService.LogDebug ("FSharpParser: Parse and check results retieved on {0}", shortFilename)
                    let defines = CompilerArguments.getDefineSymbols filePath (proj |> Option.ofNull)
                    return! ParsedDocument.create(parseOptions, results , defines)
                | None -> return FSharpParsedDocument(fileName, Flags = ParsedDocumentFlags.NonSerializable)} |> Async.RunSynchronously
              
              parsedDoc.LastWriteTimeUtc <- try File.GetLastWriteTimeUtc(fileName) with _ -> DateTime.UtcNow
              LoggingService.LogDebug ("FSharpParser: returning ParsedDocument on {0}", shortFilename)
              return parsedDoc :> _})
negative.code:     member val AllSymbolsKeyed = Dictionary<_,_>() with get, set
  
  module ParsedDocument =
    let create (parseOptions: ParseOptions) (parseResults: ParseAndCheckResults) defines =
      //Try creating tokens
      async {
        let fileName = parseOptions.FileName
  