anchor.diff:          |> Option.getOrElse [||]
           |> Array.toList
           |> List.groupBy (fun su -> su.RangeAlternate.StartLine)
  -        |> List.map (fun (line, sus) ->    
  +        |> List.map (fun (line, sus) ->
               line, 
               sus 
               |> List.map (fun su -> su.RangeAlternate.StartColumn, su.RangeAlternate.EndColumn)
  
positive.code: [<Test>]
  let ``should find usages of module level events``() =
      ("""
  let event = Event<EventHandler, EventArgs>()    
  event.Publish.AddHandler(EventHandler(fun _ _ -> ()))
  event.Trigger(null, EventArgs.Empty)
  """, 2, 5) 
  
negative.code:     => [2, [5, 9]
          3, [2, 6]]
  
  [<Test>]
  let ``should find usages of operator .>> containing '.' symbol``() =
      ("""
  let (.>>) x y = ()
  1 .>> 2
  """, 2, 8) 
      => [2, [5, 8]
          3, [2, 5]]
  
  [<Test>]
  let ``should find usages of operator >.> containing '.' symbol``() =
      ("""
  let (>.>) x y = ()
  1 >.> 2
  """, 2, 8) 
      => [2, [5, 8]
          3, [2, 5]]
  
  [<Test>]
  let ``should find usages of operator >>. containing '.' symbol``() =
      ("""
  let ( >>. ) x y = x
  1 >>. 2 >>. 3 |> ignore
  """, 2, 9) 
      => [2, [6, 9]
          3, [2, 5; 8, 11]]
  
  [<Test>]
  let ``should find usages of "at" operator``() =
      ("""
  let (@) x y = ()
  let _ = 1 @ 2
  """, 2, 6) 
      => [2, [5, 6]
          3, [10, 11]]
  
  [<Test>]
  let ``should find usages of "atat" operator``() =
      ("""
  let (@@) x y = ()
  let _ = 1 @@ 2
  """, 2, 7) 
      => [2, [5, 7]
          3, [10, 12]]
  
  [<Test>]
  let ``should find usages of "at.at" operator``() =
      ("""
  let (@.@) x y = ()
  let _ = 1 @.@ 2
  """, 2, 8) 
      => [2, [5, 8]
          3, [10, 13]]
  
  [<Test>]
  let ``should find usages of symbols if there are operators containing dots on the same line``() =
      ("""
  let ( >>. ) x y = x
  1 >>. 2 >>. 3 |> ignore
  """, 2, 9) 
      => [2, [6, 9]
          3, [2, 5; 8, 11]]
  
  [<Test>]
  let ``should find usages of fully qualified operator``() =
      ("""
  module M =
      module N =
          let (+.) x y = ()
  
  M.N.(+.) 1 2
  """, 4, 15) 
      => [4, [13, 15]
          6, [0, 7]] // ported as is. Should be (6, [5, 7])
  
  [<Test>]
  let ``should find usages of symbols followed with a punctuation symbol ','``() =
      ("""
  let f (a, b) = a + b
  """, 2, 8) 
      => [2, [7, 8; 15, 16]]
  
  [<Test>]
  let ``should find usages of symbols followed with a punctuation symbol '<'``() =
      ("""
  type C<'a> = C of 'a
  """, 2, 6) 
      => [2, [5, 6]]
  
  [<Test>]
  let ``should find usages of symbols followed with a punctuation symbol '('``() =
      ("""
  let g x = ()
  g(2)
  """, 3, 1) 
      => [2, [4, 5]
          3, [0, 1]]
  
  [<Test>]
  let ``should find all symbols in combined match patterns``() =
      ("""
  let _ = match [] with [h] | [_; h] | [h; _] -> h | _ -> 0
  """, 2, 24) 
      => [2, [23, 24; 32, 33; 38, 39; 47, 48]]
  
  [<Test>]
  let ``should not find usages inside comments``() =
      ("""
  // List.length ref
  """, 2, 7) 
      => []
  
  //[<Test>]
  //let ``should not find usages inside multi-line comments``() =
  //    hasNoSymbolUsage 713 13 "        let p = 1"
  