anchor.diff:                        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 
  +            let rec walkTycon (TypeDefn(ComponentInfo(_, _, _, _, _, _, _, _), repr, membDefns, m)) =
  +                if not (isMatchRange m) then [] else
  +                [ for memb in membDefns do yield! walkMember memb
                     match repr with
                     | SynTypeDefnRepr.ObjectModel(_, membDefns, _) -> 
  -                      for m in membDefns do yield! walkMember m 
  +                      for memb in membDefns do yield! walkMember memb
                     | _ -> () ]
                         
               // Returns class-members for the right dropdown                  
  -            and walkMember memb  = 
  +            and walkMember memb =
  +                if not (rangeContainsPos memb.Range pos) then [] else
                   [ match memb with
                     | SynMemberDefn.LetBindings(binds, _, _, _) -> yield! walkBinds binds
                     | SynMemberDefn.AutoProperty(_attribs, _isStatic, _id, _tyOpt, _propKind, _, _xmlDoc, _access, synExpr, _, _) -> yield! walkExpr true synExpr
  
positive.code:             (fun _ -> NavigationImpl.empty)   
              
      member private scope.ValidateBreakpointLocationImpl(pos) =
  
          
          // Process let-binding
          let findBreakPoints () = 
              let checkRange m = [ if rangeContainsPos m pos || m.StartLine = pos.Line 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 | _ -> () ]
  
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 _
  