anchor.diff:                            yield! walkExprOpt false whenExpr
                             yield! walkExpr true e 
   
  -                  | SynExpr.Lambda (_, _, _, e, _, _) -> 
  -                      yield! walkExpr true e 
  -
  -                  | SynExpr.Match (spBind, e, cl, _) ->
  +                  | SynExpr.Lambda (_, _, _, bodyExpr, _, _) -> 
  +                      yield! walkExpr true bodyExpr 
  +
  +                  | SynExpr.Match (spBind, inpExpr, cl, _) ->
                         yield! walkBindSeqPt spBind
  -                      yield! walkExpr false e 
  -                      for SynMatchClause(_, whenExpr, e, _, _) in cl do 
  +                      yield! walkExpr false inpExpr 
  +                      for SynMatchClause(_, whenExpr, tgtExpr, _, _) 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! walkExpr true tgtExpr 
  +
  +                  | SynExpr.LetOrUse (_, _, binds, bodyExpr, _) -> 
  +                      yield! walkBinds binds  
  +                      yield! walkExpr true bodyExpr
  +
  +                  | SynExpr.TryWith (tryExpr, _, cl, _, _, spTry, spWith) -> 
                         yield! walkTrySeqPt spTry
                         yield! walkWithSeqPt spWith
  -                      yield! walkExpr true e 
  +                      yield! walkExpr true tryExpr 
                         yield! walkMatchClauses cl
                     
                     | SynExpr.TryFinally (e1, e2, _, spTry, spFinally) ->
  
positive.code:                     | None -> None
                      | Some clause ->
                          match clause with
                          | SynMatchClause.SynMatchClause (_, whenExpr, resultExpr, _, _) ->
                              match whenExpr with
                              | None ->
                                  getIdentRangeForFuncExprInApp traverseSynExpr resultExpr pos
                              | Some whenExpr ->
  
negative.code: 
              // Determine the breakpoint locations for an expression. spAlways indicates we always
              // emit a breakpoint location for the expression unless it is a syntactic control flow construct
              and walkExpr (spAlways: bool)  expr =
                  let m = expr.Range
                  if not (isMatchRange m) then [] else
                  [ if spAlways && IsBreakableExpression expr then 
                        yield! checkRange m
  
                    match expr with
                    | SynExpr.ArbitraryAfterError _ 
                    | SynExpr.LongIdent _
                    | SynExpr.LibraryOnlyILAssembly _
  