anchor.diff:          // Find tootltip using F# compiler service & the identifier island
           let tip =
             // If we're processing an identfier, see if it has any tool tip
  -          if (tokenInfo.TokenName = "IDENT") then
  +          if (token.TokenName = "IDENT") then
               let island = List.rev island
  -            let tip = checkResults.GetIdentTooltip(line + 1, tokenInfo.LeftColumn + 1, lines.[line], island)
  +            let tip = checkResults.GetIdentTooltip(line + 1, token.LeftColumn + 1, lines.[line], island)
               match Async.RunSynchronously tip |> Option.bind ToolTipReader.tryFormatTip with 
               | Some(_) as res -> res
               | _ when island.Length > 1 ->
                   // Try to find some information about the last part of the identifier 
  -                let tip = checkResults.GetIdentTooltip(line + 1, tokenInfo.LeftColumn + 2, lines.[line], [ processDoubleBackticks body ])
  +                let tip = checkResults.GetIdentTooltip(line + 1, token.LeftColumn + 2, lines.[line], [ processDoubleBackticks body ])
                   Async.RunSynchronously tip |> Option.bind ToolTipReader.tryFormatTip
               | _ -> None
             else None
   
  -        if tokenInfo.TokenName.StartsWith("OMIT") then 
  +        if token.TokenName.StartsWith("OMIT") then 
             // Special OMIT tag - add tool tip stored in token name
             // (The text immediately follows the keyword "OMIT")
  -          yield Omitted(body, tokenInfo.TokenName.Substring(4))       
  -        elif tokenInfo.TokenName = "FSI" then
  +          yield Omitted(body, token.TokenName.Substring(4))       
  +        elif token.TokenName = "FSI" then
             // F# Interactive output - return as Output token
             yield Output(body)
           else
  
positive.code:               // way to detect this, but Visual Studio also colors these later)
                yield Token(TokenKind.Keyword, body, tip)
            | _ -> 
                match strTokenStartCol, strRange with
                | Some _, _ -> () 
                | None, None -> 
                   let kind = 
                     spans
                     |> List.tryFind (fun span -> span.WordSpan.StartCol = tokenInfo.LeftColumn)
                     |> Option.bind (fun span -> categoryToTokenKind span.Category)
                     |> Option.getOrElse (Helpers.getTokenKind tokenInfo.ColorClass)
                   yield Token (kind, body, tip)
                | None, Some (strRangeStart, strRangeEnd) -> 
                    let printfOrEscapedSpans = 
                        spans 
                        |> List.filter (fun span -> 
                            (span.Category = Category.Escaped || span.Category = Category.Printf) &&
                            span.WordSpan.StartCol >= strRangeStart &&
                            span.WordSpan.EndCol <= strRangeEnd)
  
                    match printfOrEscapedSpans with
                    | [] -> yield Token (TokenKind.String, lineStr.[strRangeStart..strRangeEnd], tip)
                    | spans ->
                        let data =
                          spans
                          |> List.fold (fun points (span: CategorizedColumnSpan<_>) ->
                              points 
                              |> Set.add span.WordSpan.StartCol
                              |> Set.add (span.WordSpan.EndCol - 1)) Set.empty
                          |> Set.add (strRangeStart - 1)
                          |> Set.add (strRangeEnd + 1)
                          |> Set.toSeq
                          |> Seq.pairwise
                          |> Seq.map (fun (leftPoint, rightPoint) ->
  
negative.code:   /// Parse the source code specified by 'source', assuming that it
    /// is located in a specified 'file'. Optional arguments can be used
    /// to give compiler command line options and preprocessor definitions
    member __.AsyncParseSource(file, source, ?options, ?defines) = async {
      let! res = agent.PostAndAsyncReply(fun chnl -> (file, source, options, defines), chnl)
      match res with
      | Choice1Of2 res -> return res
  