anchor.diff:                      None
   
           and walkSynMemberDefn (memberDefn: SynMemberDefn) =
  -            if not <| inRange memberDefn.Range pos then
  +            if not <| rangeContainsPos memberDefn.Range pos then
                   None
               else
                   match memberDefn with
  
positive.code:     ///  (2) Check symbols of those members based on ranges
      ///  (3) If any symbol found, capture its member signature 
      let getImplementedMemberSignatures (getMemberByLocation: string * range -> Async<FSharpSymbolUse option>) displayContext interfaceData = 
          let (|LongIdentPattern|_|) = function
              | SynPat.LongIdent(LongIdentWithDots(xs, _), _, _, _, _, _) ->
                  let (name, range) = xs |> Seq.map (fun x -> x.idText, x.idRange) |> Seq.last
                  Some(name, range)
              | _ -> 
                  None
  
          let (|MemberNameAndRange|_|) = function
              | Binding(_access, _bindingKind, _isInline, _isMutable, _attrs, _xmldoc, _valData, LongIdentPattern(name, range), _retTy, _expr, _bindingRange, _seqPoint) ->
                  Some(name, range)
              | _ ->
                  None
  
          let formatMemberSignature (symbolUse: FSharpSymbolUse) =
              Debug.Assert(symbolUse.Symbol :? FSharpMemberFunctionOrValue, "Only accept symbol use of members.")
              let m = symbolUse.Symbol :?> FSharpMemberFunctionOrValue
              try 
                  let signature = sprintf "%s:%s" m.DisplayName (m.FullType.Format(displayContext))
                  Some (signature.Replace(" ", ""))
              with _ ->
                  None
          async {
              match interfaceData with
              | InterfaceData.Interface(_, None) -> 
                  return Set.empty
              | InterfaceData.Interface(_, Some memberDefns) -> 
                  let! symbolUses =
                      memberDefns
                      |> Seq.choose (function (SynMemberDefn.Member(binding, _)) -> Some binding | _ -> None)
                      |> Seq.choose (|MemberNameAndRange|_|)
                      |> Seq.map getMemberByLocation
                      |> Async.Parallel
                  return symbolUses |> Seq.choose (Option.bind formatMemberSignature)
                                    |> Set.ofSeq
              | InterfaceData.ObjExpr(_, bindings) -> 
                  let! symbolUses =
                      bindings
                      |> Seq.choose (|MemberNameAndRange|_|)
                      |> Seq.map getMemberByLocation
                      |> Async.Parallel
                  return symbolUses |> Seq.choose (Option.bind formatMemberSignature)
                                    |> Set.ofSeq
          }
  
      let rec isInterface (e: FSharpEntity) =
          e.IsInterface || (e.IsFSharpAbbreviation && isInterface e.AbbreviatedType.TypeDefinition)
  
  
negative.code:         seq {
              for (iface, instantiations) in getInterfaces e do
                  yield! iface.MembersFunctionsAndValues |> Seq.choose (fun m -> 
                             // Use this hack when FCS doesn't return enough information on .NET properties and events
                             if not iface.IsFSharp && m.IsEvent && not (m.DisplayName.StartsWith "add_") && not (m.DisplayName.StartsWith "remove_") then 
                                 None
                             elif not iface.IsFSharp && m.IsProperty then 
                                 None 
                             else Some (m, instantiations))
           }
  
      let hasNoInterfaceMember e =
          getInterfaceMembers e |> Seq.isEmpty
  
      let internal (|LongIdentPattern|_|) = function
          | SynPat.LongIdent(LongIdentWithDots(xs, _), _, _, _, _, _) ->
              let (name, range) = xs |> Seq.map (fun x -> x.idText, x.idRange) |> Seq.last
              Some(name, range)
          | _ -> 
              None
  
      let internal (|MemberNameAndRange|_|) = function
          | Binding(_access, _bindingKind, _isInline, _isMutable, _attrs, _xmldoc, _valData, LongIdentPattern(name, range), _retTy, _expr, _bindingRange, _seqPoint) ->
              Some(name, range)
          | _ ->
              None
  
      /// Get associated member names and ranges
      /// In case of properties, intrinsic ranges might not be correct for the purpose of getting
      /// positions of 'member', which indicate the indentation for generating new members
      let getMemberNameAndRanges = function
          | InterfaceData.Interface(_, None) -> 
              []
          | InterfaceData.Interface(_, Some memberDefns) -> 
              memberDefns
              |> Seq.choose (function (SynMemberDefn.Member(binding, _)) -> Some binding | _ -> None)
              |> Seq.choose (|MemberNameAndRange|_|)
              |> Seq.toList
          | InterfaceData.ObjExpr(_, bindings) -> 
              List.choose (|MemberNameAndRange|_|) bindings
  
      // Sometimes interface members are stored in the form of `IInterface<'T> -> ...` so we need to get the 2nd generic arguments
      let internal (|MemberFunctionType|_|) (typ: FSharpType) =
          if typ.IsFunctionType && typ.GenericArguments.Count = 2 then
              Some typ.GenericArguments.[1]
          else None
  
      let internal (|TypeOfMember|) (m: FSharpMemberFunctionOrValue) =
          let typ = m.FullType
          match typ with
          | MemberFunctionType typ when m.IsProperty && m.EnclosingEntity.IsFSharp ->
              typ
          | _ -> typ
  
      let internal (|EventFunctionType|_|) (typ: FSharpType) =
          match typ with
          | MemberFunctionType typ ->
              if typ.IsFunctionType && typ.GenericArguments.Count = 2 then
                  let retType = typ.GenericArguments.[0]
                  let argType = typ.GenericArguments.[1]
                  if argType.GenericArguments.Count = 2 then
                      Some (argType.GenericArguments.[0], retType)
                  else None
              else None
          | _ ->
              None
  
      let internal removeWhitespace (str: string) = 
          str.Replace(" ", "")
  
      /// Ideally this info should be returned in error symbols from FCS
      /// Because it isn't, we implement a crude way of getting member signatures:
  