anchor.diff:              ctx.Writer.WriteLine(usage)
               ctx.Writer.Indent ctx.Indentation
               match getParamArgs argInfos with
  -            | "" | "()" ->
  +            | "", _ | "()", _ ->
                   ctx.Writer.WriteLine("with set (v: {0}): unit = ", retType)
  -            | args ->
  -                ctx.Writer.WriteLine("with set {0} (v: {1}): unit = ", args, retType)
  +            | args, namesWithIndices ->
  +                let valueArgName, _ = normalizeArgName namesWithIndices "v"
  +                ctx.Writer.WriteLine("with set {0} ({1}: {2}): unit = ", args, valueArgName, retType)
               ctx.Writer.Indent ctx.Indentation
               for line in ctx.MethodBody do
                   ctx.Writer.WriteLine(line)
  
positive.code: 
      let internal keywordSet = set Microsoft.FSharp.Compiler.Lexhelp.Keywords.keywordNames
  
      // Format each argument, including its name and type 
      let internal formatArgUsage ctx hasTypeAnnotation (namesWithIndexes: 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)
              | 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
  
          // 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
  
      let internal formatArgsUsage ctx hasTypeAnnotation (v: FSharpMemberFunctionOrValue) args =
          let isItemIndexer = (v.IsInstanceMember && v.DisplayName = "Item")
          let unit, argSep, tupSep = "()", " ", ", "
          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 
  
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
  