anchor.diff:              (fun _ -> NavigationImpl.empty)   
               
       member private scope.ValidateBreakpointLocationImpl(pos) =
  -
  -        
  +        let isMatchRange m = rangeContainsPos m pos || m.StartLine = pos.Line
  +
           // Process let-binding
           let findBreakPoints () = 
  -            let checkRange m = [ if rangeContainsPos m pos || m.StartLine = pos.Line then yield m ]
  +            let checkRange m = [ if isMatchRange m then yield m ]
               let walkBindSeqPt sp = [ match sp with SequencePointAtBinding m -> yield! checkRange m | _ -> () ]
               let walkForSeqPt sp = [ match sp with SequencePointAtForLoop m -> yield! checkRange m | _ -> () ]
               let walkWhileSeqPt sp = [ match sp with SequencePointAtWhileLoop m -> yield! checkRange m | _ -> () ]
  
positive.code:                 let locations = findBreakPoints()
                  
                  match locations |> List.filter (fun m -> rangeContainsPos m pos) with
                  | [] -> Seq.tryHead locations
                  | locations -> Seq.tryLast locations)
              (fun _msg -> None)  
              
      /// When these files appear or disappear the configuration for the current project is invalidated.
      member scope.DependencyFiles = dependencyFiles
  
negative.code: 
                    yield! walkExpr (isFunction || (match spInfo with SequencePointAtBinding _ -> false | _-> true)) synExpr ]
  
              and walkExprs es = List.collect (walkExpr false) es
              and walkBinds es = List.collect walkBind es
              and walkMatchClauses cl = 
                  [ for (Clause(_,whenExpr,e,_,_)) in cl do 
                      match whenExpr with 
                      | Some e -> yield! walkExpr false e 
                      | _ -> ()
                      yield! walkExpr true e ]
  
              and walkExprOpt (spAlways:bool) eOpt = [ match eOpt with Some e -> yield! walkExpr spAlways e | _ -> () ]
              
              and IsBreakableExpression e =
                  match e with
                  | SynExpr.Match _
                  | SynExpr.IfThenElse _
                  | SynExpr.For _
                  | SynExpr.ForEach _
                  | SynExpr.While _ -> true
                  | _ -> not (IsControlFlowExpression e)
  
              // 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)  e =
                  let m = e.Range
                  if not (isMatchRange m) then [] else
                  [ if spAlways && IsBreakableExpression e then 
                        yield! checkRange m
  
                    match e with
                    | SynExpr.ArbitraryAfterError _ 
                    | SynExpr.LongIdent _
                    | SynExpr.LibraryOnlyILAssembly _
  