anchor.diff:  [<Test>]
   let ``should find usages of generic parameters``() =
       checkSymbolUsage 707 12 "    type C<'a> = C of 'a" 
  -        [ (707, 11), (707, 13)
  -          (707, 22), (707, 24) ]
  +        [ (707, 11, 13); (707, 22, 24) ]
   
   [<Test>]
   let ``should find usages of statically resolved type parameters``() =
       checkSymbolUsage 730 22 "    let inline check< ^T when ^T : (static member IsInfinity : ^T -> bool)> (num: ^T) : ^T option =" 
  -        [ (730, 22), (730, 24)
  -          (730, 30), (730, 32) 
  -          (730, 63), (730, 65) 
  -          (730, 82), (730, 84) 
  -          (730, 88), (730, 90)
  -          (731, 12), (731, 14)
  -          (731, 44), (731, 46) ] 
  +        [ (730, 22, 24)
  +          (730, 30, 32) 
  +          (730, 63, 65) 
  +          (730, 82, 84) 
  +          (730, 88, 90)
  +          (731, 12, 14)
  +          (731, 44, 46) ] 
   
   [<Test>]
   let ``should find usages of named discriminated union fields``() =
       checkSymbolUsage 735 15 "        | B of field1: int * field2: string" 
  -        [ (735, 15), (735, 21)
  -          (737, 15), (737, 21)
  -          (740, 13), (740, 19) ]
  +        [ (735, 15, 21)
  +          (737, 15, 21)
  +          (740, 13, 19) ]
   
   [<Test>]
   let ``should find usages of active patterns``() =
       checkSymbolUsage 744 10 "    let (|A|Bb|Ccc|) (x: int) =" 
  -        [ (744, 10), (744, 11)
  -          (745, 22), (745, 23)
  -          (749, 10), (749, 11) ]
  +        [ (744, 10, 11)
  +          (745, 22, 23)
  +          (749, 10, 11) ]
   
   [<Test>]
   let ``should find usages of statically resolved method names``() =
       checkSymbolUsage 754 54 "    let inline checkIt< ^T when ^T : (static member IsInfinity : ^T -> bool)> (num: ^T) : ^T option =" 
  -        [ (754, 52), (754, 62) ]
  +        [ (754, 52, 62) ]
       
       checkSymbolUsage 755 32 "        if (^T : (static member IsInfinity: ^T -> bool) (num)) then None" 
  -        [ (755, 32), (755, 42) ]
  +        [ (755, 32, 42) ]
   
   [<Test>]
   let ``should find usages of property initializers``() =
       checkSymbolUsage 759 19 """        member val Prop = "" with get, set"""
  -        [ (759, 19), (759, 23)
  -          (761, 14), (761, 18) ]
  +        [ (759, 19, 23)
  +          (761, 14, 18) ]
   
   [<Test; Ignore "FCS 0.0.36 does not support this">]
   let ``should find usages of properties with explicit getters and setters``() =
       checkSymbolUsage 766 17 "        member x.Name"
  -        [ (766, 17), (766, 21)]
  +        [ (766, 17, 21)]
   
   [<Test>] 
   let ``should find usages of fully qualified record fields``() =
       checkSymbolUsage 770 9 "    type Record = { Field: int }"
  -        [ (770, 9), (770, 15) ]
  +        [ (770, 9, 15) ]
             // (771, 14), (771, 20) ] FCS 0.0.36 does not support this
   
       checkSymbolUsage 771 14 "    let r = { Record.Field = 1 }"
  -        [ (770, 9), (770, 15) ]
  +        [ (770, 9, 15) ]
             // (771, 14), (771, 20) ] FCS 0.0.36 does not support this
   
   type ITempSource = 
  
positive.code:     |> Option.map (fun (_, _, symbolUses) -> 
          symbolUses |> Array.map (fun x -> 
                          let r = x.RangeAlternate
                          ((r.StartLine-1, r.StartColumn), (r.EndLine-1, r.EndColumn))))
      |> Option.map set
  
  let checkSymbolUsage line col lineStr expected =
  
negative.code: let ``should find usages of symbols contacting with a special symbol on the right``() =
      checkSymbolUsage
          706 12 "    let f (a, b) = a + b"
          [ (706, 11, 12); (706, 19, 20) ]
  
      checkSymbolUsage
          707 9 "    type C<'a> = C of 'a"
          [ (707, 9, 10) ]
  
      checkSymbolUsage
          707 10 "    type C<'a> = C of 'a"
          [ (707, 9, 10) ]
  
      checkSymbolUsage
          709 5 "    g(2)"
          [ (708, 8, 9); (709, 4, 5) ]
  
  [<Test>]
  let ``should find all symbols in combined match patterns``() =
      checkSymbolUsage
          763 27 "    let _ = match [] with [h] | [_; h] | [_; _; h] -> h | _ -> 0"
          [(763, 27, 28); (763, 36, 37); (763, 42, 43); (763, 51, 52)]
  
  [<Test>]
  let ``should not find usages inside comments``() =
  