anchor.diff:  
       let internal keywordSet = set Microsoft.FSharp.Compiler.Lexhelp.Keywords.keywordNames
   
  +    type NamesWithIndices = Map<string, Set<int>>
  +
  +    let normalizeArgName (namesWithIndices: NamesWithIndices) nm =
  +        match nm with
  +        | "()" -> nm, namesWithIndices
  +        | _ ->
  +            let nm, index = String.extractTrailingIndex nm
  +                
  +            let index, namesWithIndices =
  +                match namesWithIndices |> Map.tryFind nm, index with
  +                | Some indexes, index ->
  +                    let rec getAvailableIndex idx =
  +                        if indexes |> Set.contains idx then 
  +                            getAvailableIndex (idx + 1)
  +                        else idx
  +                    let index = index |> Option.getOrElse 1 |> getAvailableIndex
  +                    Some index, namesWithIndices |> Map.add nm (indexes |> Set.add index)
  +                | None, Some index -> Some index, namesWithIndices |> Map.add nm (Set.ofList [index])
  +                | None, None -> None, namesWithIndices |> Map.add nm Set.empty
  +
  +            let nm = 
  +                match index with
  +                | Some index -> sprintf "%s%d" nm index
  +                | None -> nm
  +            let nm = if Set.contains nm keywordSet then sprintf "``%s``" nm else nm
  +            nm, namesWithIndices
  +
       // Format each argument, including its name and type 
  -    let internal formatArgUsage ctx hasTypeAnnotation (namesWithIndexes: Map<string, Set<int>>) (arg: FSharpParameter) = 
  +    let internal formatArgUsage ctx hasTypeAnnotation (namesWithIndices: Map<string, Set<int>>) (arg: FSharpParameter) = 
           let nm = 
               match arg.Name with 
               | None ->
                   if arg.Type.HasTypeDefinition && arg.Type.TypeDefinition.XmlDocSig = "T:Microsoft.FSharp.Core.unit" then "()" 
  -                else sprintf "arg%d" (namesWithIndexes |> Map.toList |> List.map snd |> List.sumBy Set.count |> max 1)
  +                else sprintf "arg%d" (namesWithIndices |> Map.toList |> List.map snd |> List.sumBy Set.count |> max 1)
               | Some x -> String.lowerCaseFirstChar x
           
  -        let nm, namesWithIndexes =
  -            match nm with
  -            | "()" -> nm, namesWithIndexes
  -            | _ ->
  -                let nm, index = String.extractTrailingIndex nm
  -                
  -                let index, namesWithIndexes =
  -                    match namesWithIndexes |> Map.tryFind nm, index with
  -                    | Some indexes, Some index ->
  -                        let rec getAvailableIndex idx =
  -                            match indexes |> Set.contains idx with
  -                            | true -> getAvailableIndex (idx + 1)
  -                            | false -> idx
  -                        let index = getAvailableIndex index
  -                        Some index, namesWithIndexes |> Map.add nm (indexes |> Set.add index)
  -                    | Some indexes, None ->
  -                        let rec getAvailableIndex idx =
  -                            match indexes |> Set.contains idx with
  -                            | true -> getAvailableIndex (idx + 1)
  -                            | false -> idx
  -                        let index = getAvailableIndex 1
  -                        Some index, namesWithIndexes |> Map.add nm (indexes |> Set.add index)
  -                    | None, Some index -> Some index, namesWithIndexes |> Map.add nm (Set.ofList [index])
  -                    | None, None -> None, namesWithIndexes |> Map.add nm Set.empty
  -
  -                (match index with
  -                 | Some index -> sprintf "%s%d" nm index
  -                 | None -> nm)
  -                , namesWithIndexes
  -
  -        let nm = if Set.contains nm keywordSet then sprintf "``%s``" nm else nm
  -
  +        let nm, namesWithIndices = normalizeArgName namesWithIndices nm
  +        
           // Detect an optional argument
           let isOptionalArg = hasAttrib<OptionalArgumentAttribute> arg.Attributes
           let argName = if isOptionalArg then "?" + nm else nm
           (if hasTypeAnnotation && argName <> "()" then 
               argName + ": " + formatType ctx arg.Type
           else argName),
  -        namesWithIndexes
  +        namesWithIndices
   
       let internal formatArgsUsage ctx hasTypeAnnotation (v: FSharpMemberFunctionOrValue) args =
           let isItemIndexer = (v.IsInstanceMember && v.DisplayName = "Item")
           let unit, argSep, tupSep = "()", " ", ", "
  +        let args, namesWithIndices =
  +            args
  +            |> List.fold (fun (argsSoFar: string list list, namesWithIndices) args ->
  +                let argsSoFar', namesWithIndices =
  +                    args 
  +                    |> List.fold (fun (acc: string list, allNames) arg -> 
  +                        let name, allNames = formatArgUsage ctx hasTypeAnnotation allNames arg
  +                        name :: acc, allNames) ([], namesWithIndices)
  +                List.rev argsSoFar' :: argsSoFar, namesWithIndices) 
  +                ([], Map.ofList [ ctx.ObjectIdent, Set.empty ])
           args
  -        |> List.fold (fun (argsSoFar: string list list, namesWithIndexes) args ->
  -            let argsSoFar', namesWithIndexes =
  -                args 
  -                |> List.fold (fun (acc: string list, allNames) arg -> 
  -                    let name, allNames = formatArgUsage ctx hasTypeAnnotation allNames arg
  -                    name :: acc, allNames) ([], namesWithIndexes)
  -            List.rev argsSoFar' :: argsSoFar, namesWithIndexes) 
  -            ([], Map.ofList [ ctx.ObjectIdent, Set.empty ])
  -        |> fst 
           |> List.rev
           |> List.map (function 
               | [] -> unit 
  
positive.code:             | args when isItemIndexer -> String.concat tupSep args
              | args -> bracket (String.concat tupSep args))
          |> String.concat argSep
    
      let internal formatMember (ctx: Context) (v: FSharpMemberFunctionOrValue) = 
          let getParamArgs (argInfos: FSharpParameter list list) = 
              let args =
                  match argInfos with
                  | [[x]] when v.IsGetterMethod && x.Name.IsNone 
                              && x.Type.TypeDefinition.XmlDocSig = "T:Microsoft.FSharp.Core.unit" -> ""
                  | _  -> formatArgsUsage ctx true v argInfos
               
              if String.IsNullOrWhiteSpace(args) then "" 
              elif args.StartsWith("(") then args
              else sprintf "(%s)" args
  
          let buildUsage argInfos = 
              let parArgs = getParamArgs argInfos
              match v.IsMember, v.IsInstanceMember, v.LogicalName, v.DisplayName with
              // Constructors
              | _, _, ".ctor", _ -> "new" + parArgs
  
negative.code:             ctx.Writer.WriteLine(usage)
              ctx.Writer.Indent ctx.Indentation
              match getParamArgs argInfos with
              | "", _ ->
                  ctx.Writer.WriteLine("with get (): {0} = ", retType)
              | args, _ ->
                  ctx.Writer.WriteLine("with get {0}: {1} = ", args, retType)
              ctx.Writer.Indent ctx.Indentation
              for line in ctx.MethodBody do
  