anchor.diff:          let rec getIdentRangeForFuncExprInApp traverseSynExpr expr pos =
               match expr with
               | SynExpr.Ident ident -> Some ident.idRange
  -            
  -            | SynExpr.LongIdent(_, _, _, range) -> Some range
  -
  -            | SynExpr.Paren(expr, _, _, range) when rangeContainsPos range pos ->
  +        
  +            | SynExpr.LongIdent (_, _, _, range) -> Some range
  +
  +            | SynExpr.Paren (expr, _, _, range) when rangeContainsPos range pos ->
                   getIdentRangeForFuncExprInApp traverseSynExpr expr pos
   
  -            // This matches computation expressions like 'async { ... }'
  -            | SynExpr.App(_, _, _, SynExpr.CompExpr (_, _, expr, range), _) when rangeContainsPos range pos ->
  -                getIdentRangeForFuncExprInApp traverseSynExpr expr pos
  -
  -            | SynExpr.App(_, _, funcExpr, argExpr, _) ->
  +            | SynExpr.App (_, _, funcExpr, argExpr, _) ->
                   match argExpr with
                   | SynExpr.App (_, _, _, _, range) when rangeContainsPos range pos ->
                       getIdentRangeForFuncExprInApp traverseSynExpr argExpr pos
   
  -                | SynExpr.Paren(SynExpr.Lambda(_, _, _args, body, _, _), _, _, _) when rangeContainsPos body.Range pos -> 
  -                    getIdentRangeForFuncExprInApp traverseSynExpr body pos
  +                // Special case: `async { ... }` is actually a CompExpr inside of the argExpr of a SynExpr.App
  +                | SynExpr.CompExpr (_, _, expr, range) when rangeContainsPos range pos ->
  +                    getIdentRangeForFuncExprInApp traverseSynExpr expr pos
  +
  +                | SynExpr.Paren (expr, _, _, range) when rangeContainsPos range pos ->
  +                    getIdentRangeForFuncExprInApp traverseSynExpr expr pos
   
                   | _ ->
                       match funcExpr with
  
positive.code:                         // of the identifier of the function we're after
                          getIdentRangeForFuncExprInApp traverseSynExpr funcExpr pos
  
              | SynExpr.LetOrUse(_, _, bindings, body, range) when rangeContainsPos range pos  ->
                  let binding =
                      bindings
                      |> List.tryFind (fun x -> rangeContainsPos x.RangeOfBindingWithRhs pos)
                  match binding with
                  | Some(SynBinding(_, _, _, _, _, _, _, _, _, expr, _, _)) ->
                      getIdentRangeForFuncExprInApp traverseSynExpr expr pos
                  | None ->
                      getIdentRangeForFuncExprInApp traverseSynExpr body pos
  
              | expr ->
                  traverseSynExpr expr
  
negative.code:                     | _ -> defaultTraverse expr
              })
          | None -> None
  
  
      member scope.GetAllArgumentsForFunctionApplicationAtPostion pos =
          match input with
  