anchor.diff:          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
  -                           if iface.IsFSharp || not m.IsProperty then Some (m, instantiations) else None)
  +                           // 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:
  
positive.code:                     None
  
          and walkSynTypeDefn(TypeDefn(_componentInfo, representation, members, range)) = 
              if not <| inRange range pos then
                  None
              else
                  walkSynTypeDefnRepr representation
                  |> Option.orElse (List.tryPick walkSynMemberDefn members)        
  
          and walkSynTypeDefnRepr(typeDefnRepr: SynTypeDefnRepr) = 
              if not <| inRange typeDefnRepr.Range pos then
                  None
              else
                  match typeDefnRepr with
  
negative.code:                     None
  
          and walkSynMemberDefn (memberDefn: SynMemberDefn) =
              if not <| rangeContainsPos memberDefn.Range pos then
                  None
              else
                  match memberDefn with
  