anchor.diff:                  let locations = findBreakPoints()
                   
                   match locations |> List.filter (fun m -> rangeContainsPos m pos) with
  -                | [] -> Seq.tryHead locations
  -                | locations -> Seq.tryLast locations)
  -            (fun _msg -> None)  
  +                | [] ->
  +                    match locations |> List.filter (fun m -> rangeBeforePos m pos |> not) with
  +                    | [] -> Seq.tryHead locations
  +                    | locationsAfterPos -> Seq.tryHead locationsAfterPos
  +                | coveringLocations -> Seq.tryLast coveringLocations)
  +            (fun _msg -> None)
               
       /// When these files appear or disappear the configuration for the current project is invalidated.
       member scope.DependencyFiles = dependencyFiles
  
positive.code:                       yield! walkExpr true e2 ]
              
              // Process a class declaration or F# type declaration
              let rec walkTycon (TypeDefn(ComponentInfo(_, _, _, _, _, _, _, _), repr, membDefns, _)) =
                  [ for m in membDefns do yield! walkMember m 
                    match repr with
                    | SynTypeDefnRepr.ObjectModel(_, membDefns, _) -> 
                        for m in membDefns do yield! walkMember m 
                    | _ -> () ]
                        
              // Returns class-members for the right dropdown                  
              and walkMember memb  = 
                  [ match memb with
                    | SynMemberDefn.LetBindings(binds, _, _, _) -> yield! walkBinds binds
                    | SynMemberDefn.AutoProperty(_attribs, _isStatic, _id, _tyOpt, _propKind, _, _xmlDoc, _access, synExpr, _, _) -> yield! walkExpr true synExpr
  
negative.code:             // (such as type declarations, nested modules etc.)                            
              let rec walkDecl decl = 
                  [ match decl with 
                    | SynModuleDecl.Let(_, binds, m) when isMatchRange m -> 
                        yield! walkBinds binds
                    | SynModuleDecl.DoExpr(spExpr,expr, m) when isMatchRange m ->  
                        yield! walkBindSeqPt spExpr
                        yield! walkExpr false expr
                    | SynModuleDecl.ModuleAbbrev _ -> ()
                    | SynModuleDecl.NestedModule(_, _isRec, decls, _, m) when isMatchRange m ->
                        for d in decls do yield! walkDecl d
                    | SynModuleDecl.Types(tydefs, m) when isMatchRange m -> 
                        for d in tydefs do yield! walkTycon d
                    | SynModuleDecl.Exception(SynExceptionDefn(SynExceptionDefnRepr(_, _, _, _, _, _), membDefns, _), m) 
                          when isMatchRange m ->
                        for m in membDefns do yield! walkMember m
                    | _ -> () ] 
                        
              // Collect all the items in a module  
              let walkModule (SynModuleOrNamespace(_,_,_,decls,_,_,_,m)) =
                  if isMatchRange m then
                      List.collect walkDecl decls
                  else
                      []
                        
             /// Get information for implementation file        
              let walkImplFile (modules:SynModuleOrNamespace list) = List.collect walkModule modules
                       
              match input with
              | Some(ParsedInput.ImplFile(ParsedImplFileInput(_,_,_,_,_,modules,_))) -> walkImplFile modules 
  