anchor.diff:              typ.Range
           | InterfaceData.ObjExpr(typ, _) -> 
               typ.Range
  -    member x.MemberCount =
  -        match x with
  -        | InterfaceData.Interface(_, None) -> 
  -            0
  -        | InterfaceData.Interface(_, Some members) -> 
  -            List.length members
  -        | InterfaceData.ObjExpr(_, bindings) ->
  -            List.length bindings
       member x.TypeParameters = 
           match x with
           | InterfaceData.Interface(typ, _)
  
positive.code:                            if iface.IsFSharp || not m.IsProperty then Some (m, instantiations) else None)
           }
  
      let countInterfaceMembers e =
          getInterfaceMembers e |> Seq.length
  
      let rec isInterface (e: FSharpEntity) =
          e.IsInterface || (e.IsFSharpAbbreviation && isInterface e.AbbreviatedType.TypeDefinition)
  
      /// Generate stub implementation of an interface at a start column
      let formatInterface startColumn indentation (typeInstances: string []) objectIdent 
              (methodBody: string) (displayContext: FSharpDisplayContext) (e: FSharpEntity) =
          Debug.Assert(isInterface e, "The entity should be an interface.")
          use writer = new ColumnIndentedTextWriter()
          let lines = methodBody.Replace("\r\n", "\n").Split('\n')
          let typeParams = Seq.map getTypeParameterName e.GenericParameters
          let instantiations = 
              let insts =
  
negative.code:             if e.IsFSharpAbbreviation then
                  let typ = getNonAbbreviatedType e.AbbreviatedType
                  (typ.TypeDefinition.GenericParameters |> Seq.map getTypeParameterName, 
                      typ.GenericArguments |> Seq.map (fun typ -> typ.Format(displayContext)))
                  ||> Seq.zip
                  |> Seq.fold (fun acc (x, y) -> Map.add x y acc) insts
              else insts
          let ctx = { Writer = writer; TypeInstantations = instantiations; ArgInstantiations = Seq.empty;
                      Indentation = indentation; ObjectIdent = objectIdent; MethodBody = lines; DisplayContext = displayContext }
          let missingMembers =
              getInterfaceMembers e
              |> Seq.filter (fun (m, insts) -> 
                  // FullType might throw exceptions due to bugs in FCS
                  try
                      Debug.Assert(m.FullType.IsFunctionType, "An interface member has to be of function type.")
                      let fullSignature = sprintf "%s:%s" m.DisplayName (formatType { ctx with ArgInstantiations = insts }  m.FullType)
                      // Sometimes interface members are stored in the form of `IInterface<'T> -> ...` so we need to get the 2nd generic arguments
                      let partialSignature = sprintf "%s:%s" m.DisplayName (formatType { ctx with ArgInstantiations = insts }  m.FullType.GenericArguments.[1])
                      not (Set.contains (fullSignature.Replace(" ", "")) excludedMemberSignatures || Set.contains (partialSignature.Replace(" ", "")) excludedMemberSignatures) 
                  with _ -> true)
          // All members are already implemented
          if Seq.isEmpty missingMembers then
              String.Empty
          else
              writer.Indent startColumn
              for (m, insts) in missingMembers do
                  formatMember { ctx with ArgInstantiations = insts } m
              writer.Dump()
  
      let internal (|IndexerArg|) = function
          | SynIndexerArg.Two(e1, e2) -> [e1; e2]
  