anchor.diff:                      | None -> None
                       | Some clause ->
                           match clause with
  -                        | SynMatchClause.SynMatchClause (_, whenExpr, resultExpr, _, _) ->
  -                            match whenExpr with
  +                        | SynMatchClause.SynMatchClause (_, whenExprOpt, resultExpr, _, _) ->
  +                            match whenExprOpt with
                               | None ->
                                   getIdentRangeForFuncExprInApp traverseSynExpr resultExpr pos
                               | Some whenExpr ->
  
positive.code:                           yield! walkExprOpt false whenExpr
                            yield! walkExpr true e 
  
                    | SynExpr.Lambda (_, _, _, e, _, _) -> 
                        yield! walkExpr true e 
  
                    | SynExpr.Match (spBind, e, cl, _) ->
                        yield! walkBindSeqPt spBind
                        yield! walkExpr false e 
                        for SynMatchClause(_, whenExpr, e, _, _) in cl do 
                            yield! walkExprOpt false whenExpr
                            yield! walkExpr true e 
  
                    | SynExpr.LetOrUse (_, _, bs, e, _) -> 
                        yield! walkBinds bs  
                        yield! walkExpr true e
  
                    | SynExpr.TryWith (e, _, cl, _, _, spTry, spWith) -> 
                        yield! walkTrySeqPt spTry
                        yield! walkWithSeqPt spWith
                        yield! walkExpr true e 
                        yield! walkMatchClauses cl
                    
                    | SynExpr.TryFinally (e1, e2, _, spTry, spFinally) ->
  
negative.code:                   yield! walkExpr (isFunction || (match spInfo with DebugPointAtBinding.Yes _ -> false | _-> true)) synExpr ]
  
              and walkExprs es = List.collect (walkExpr false) es
  
              and walkBinds es = List.collect walkBind es
  
              and walkMatchClauses cl = 
                  [ for SynMatchClause(_, whenExprOpt, tgtExpr, _, _) in cl do 
                      match whenExprOpt with 
                      | Some whenExpr -> yield! walkExpr false whenExpr 
                      | _ -> ()
                      yield! walkExpr true tgtExpr ]
  
              and walkExprOpt (spAlways: bool) eOpt =
                  [ match eOpt with Some e -> yield! walkExpr spAlways e | _ -> () ]
              
              and IsBreakableExpression e =
                  match e with
  