anchor.diff:              else sprintf "(%s)" args
               , namesWithIndices
   
  -        let buildUsage argInfos = 
  -            let parArgs, _ = getParamArgs argInfos
  -            match v.IsMember, v.IsInstanceMember, v.LogicalName, v.DisplayName with
  -            // Constructors
  -            | _, _, ".ctor", _ -> "new" + parArgs
  -            // Properties (skipping arguments)
  -            | _, true, _, name when v.IsPropertyGetterMethod || v.IsPropertySetterMethod -> 
  -                if name.StartsWith("get_") || name.StartsWith("set_") then name.[4..] else name
  -            // Ordinary instance members
  -            | _, true, _, name -> name + parArgs
  -            // Ordinary functions or values
  -            | false, _, _, name when 
  -                not (hasAttribute<RequireQualifiedAccessAttribute> v.LogicalEnclosingEntity.Attributes) -> 
  -                name + " " + parArgs
  -            // Ordinary static members or things (?) that require fully qualified access
  -            | _, _, _, name -> name + parArgs
  -
  -        let modifiers =
  -            [ if v.InlineAnnotation = FSharpInlineAnnotation.AlwaysInline then yield "inline"
  -              if v.Accessibility.IsInternal then yield "internal" ]
  -
  -        let argInfos = 
  -            v.CurriedParameterGroups |> Seq.map Seq.toList |> Seq.toList 
  -            
  -        let retType = v.ReturnParameter.Type
  -
  -        let argInfos, retType = 
  -            match argInfos, v.IsPropertyGetterMethod, v.IsPropertySetterMethod with
  -            | [ AllAndLast(args, last) ], _, true -> [ args ], Some last.Type
  -            | [[]], true, _ -> [], Some retType
  -            | _, _, _ -> argInfos, Some retType
  -
  -        let retType = defaultArg (retType |> Option.map (formatType ctx)) "unit"
  -        let usage = buildUsage argInfos
  -
  -        let writer = ctx.Writer
  -        writer.WriteLine("")
  -        if v.IsEvent || hasAttribute<CLIEventAttribute> v.Attributes then
  -            writer.WriteLine("[<CLIEvent>]")
  -        writer.Write("member ")
  -        for modifier in modifiers do
  -            writer.Write("{0} ", modifier)
  -        writer.Write("{0}.", ctx.ObjectIdent)
  -        
  -        if v.IsEvent then
  -            writer.Write(usage)
  -            writer.WriteLine(": {0} = ", retType)
  -            writer.Indent ctx.Indentation
  -            for line in ctx.MethodBody do
  -                writer.WriteLine(line)
  -            writer.Unindent ctx.Indentation
  -        elif v.IsPropertySetterMethod then
  +        let preprocess (ctx: Context) (v: FSharpMemberFunctionOrValue) = 
  +            let buildUsage argInfos = 
  +                let parArgs, _ = getParamArgs argInfos ctx v
  +                match v.IsMember, v.IsInstanceMember, v.LogicalName, v.DisplayName with
  +                // Constructors
  +                | _, _, ".ctor", _ -> "new" + parArgs
  +                // Properties (skipping arguments)
  +                | _, true, _, name when v.IsPropertyGetterMethod || v.IsPropertySetterMethod -> 
  +                    if name.StartsWith("get_") || name.StartsWith("set_") then name.[4..] else name
  +                // Ordinary instance members
  +                | _, true, _, name -> name + parArgs
  +                // Ordinary functions or values
  +                | false, _, _, name when 
  +                    not (hasAttribute<RequireQualifiedAccessAttribute> v.LogicalEnclosingEntity.Attributes) -> 
  +                    name + " " + parArgs
  +                // Ordinary static members or things (?) that require fully qualified access
  +                | _, _, _, name -> name + parArgs
  +
  +            let modifiers =
  +                [ if v.InlineAnnotation = FSharpInlineAnnotation.AlwaysInline then yield "inline"
  +                  if v.Accessibility.IsInternal then yield "internal" ]
  +
  +            let argInfos, retType = getArgTypes ctx v
  +            let usage = buildUsage argInfos
  +            usage, modifiers, argInfos, retType
  +
  +        match m with
  +        | MemberInfo.PropertyGetSet(getter, setter) ->
  +            let (usage, modifiers, getterArgInfos, retType) = preprocess ctx getter
  +            let (_, _, setterArgInfos, _) = preprocess ctx setter
  +            let writer = ctx.Writer
  +            writer.WriteLine("")
  +            if getter.IsEvent || hasAttribute<CLIEventAttribute> getter.Attributes then
  +                writer.WriteLine("[<CLIEvent>]")
  +            writer.Write("member ")
  +            for modifier in modifiers do
  +                writer.Write("{0} ", modifier)
  +            writer.Write("{0}.", ctx.ObjectIdent)
  +
  +            // Try to print getters and setters on the same identifier
               writer.WriteLine(usage)
               writer.Indent ctx.Indentation
  -            match getParamArgs argInfos with
  -            | "", _ | "()", _ ->
  -                writer.WriteLine("with set (v: {0}): unit = ", retType)
  -            | args, namesWithIndices ->
  -                let valueArgName, _ = normalizeArgName namesWithIndices "v"
  -                writer.WriteLine("with set {0} ({1}: {2}): unit = ", args, valueArgName, retType)
  -            writer.Indent ctx.Indentation
  -            for line in ctx.MethodBody do
  -                writer.WriteLine(line)
  -            writer.Unindent ctx.Indentation
  -            writer.Unindent ctx.Indentation
  -        elif v.IsPropertyGetterMethod then
  -            writer.WriteLine(usage)
  -            writer.Indent ctx.Indentation
  -            match getParamArgs argInfos with
  +            match getParamArgs getterArgInfos ctx getter with
               | "", _ | "()", _ ->
                   writer.WriteLine("with get (): {0} = ", retType)
               | args, _ ->
  
positive.code:             String.Empty
          else
              writer.Indent startColumn
              for (m, insts) in missingMembers do
                  formatMember { ctx with ArgInstantiations = insts } m
              writer.Dump()
  
      let tryFindInterfaceDeclaration (pos: pos) (parsedInput: ParsedInput) =
  
negative.code:             | args -> bracket (String.concat tupSep args))
          |> String.concat argSep
          , namesWithIndices
  
      [<RequireQualifiedAccess>]
      type MemberInfo =
          | PropertyGetSet of FSharpMemberFunctionOrValue * FSharpMemberFunctionOrValue
          | Member of FSharpMemberFunctionOrValue
  
      let internal getArgTypes (ctx: Context) (v: FSharpMemberFunctionOrValue) =
          let argInfos = 
              v.CurriedParameterGroups |> Seq.map Seq.toList |> Seq.toList 
              
          let retType = v.ReturnParameter.Type
  
          let argInfos, retType = 
              match argInfos, v.IsPropertyGetterMethod, v.IsPropertySetterMethod with
              | [ AllAndLast(args, last) ], _, true -> [ args ], Some last.Type
              | [[]], true, _ -> [], Some retType
              | _, _, _ -> argInfos, Some retType
  
          let retType = defaultArg (retType |> Option.map (formatType ctx)) "unit"      
          argInfos, retType
  
      let normalizePropertyName (v: FSharpMemberFunctionOrValue) =
          let displayName = v.DisplayName
          if (v.IsPropertyGetterMethod && displayName.StartsWith("get_")) || 
              (v.IsPropertySetterMethod && displayName.StartsWith("set_")) then
              displayName.[4..]
          else displayName
      
      let internal formatMember (ctx: Context) m = 
          let getParamArgs (argInfos: FSharpParameter list list) (ctx: Context) (v: FSharpMemberFunctionOrValue) = 
              let args, namesWithIndices =
                  match argInfos with
                  | [[x]] when v.IsPropertyGetterMethod && x.Name.IsNone 
                                  && x.Type.TypeDefinition.XmlDocSig = "T:Microsoft.FSharp.Core.unit" -> 
                      "", Map.ofList [ctx.ObjectIdent, Set.empty]
                  | _  -> formatArgsUsage ctx true v argInfos
               
  