I don't see the indentation you describe. I see

    f((some
        multiline
        arg),
        (another
            multline
            arg))

This seems consistent even if it is odd in this example. Each continuation is indented one tab stop from the start of the sequence.

Yes, that particular example was misleading because I meant for pieces of each arg to be internally indented (and "arg" behaves differently if it is a closing delimiter).

The case I'm trying to avoid is this:

f(s{
    x: 0,
},
    s{
        x: 1,
    },
)

which is confusing. Yes, I get that this is just what happens when the indentation of individual function args is independent of the indentation of the function arg list, but I don't see what would be harmed if, when a multiline arg starts on the first line of the function call and some other arg uses the function arg list's indentation, the continuation of the first multiline arg (and subsequent args following its indentation) were additionally indented by the function arg list's indentation.

So you would have this:

type s struct {
    x int
}

func f(ss ...s) {}

func main() {
    // This indentation remains the same
    f(s{
        x: 0,
    })

    // As does this
    f(s{
        x: 0,
    }, s{
        x: 1,
    })

    // The presence of the third argument starting on an indented line
    // causes the first two arguments' continuations to be indented
    f(s{
            x: 0,
        }, s{
            x: 1,
        },
        s{
            x: 2,
        },
    )
}

@griesemer

Given @ianlancetaylor 's example, it's worth thinking about whether this behavior (when the last line of the arg doesn't start with a closing delimiter) is desirable:

fmt.Println("Hello", fmt.Sprintf("%s %s %s",
    "world",
    "and",
    "goodbye!"), fmt.Sprintf("%s %s %s", "Still",
    "here",
    "though."),
    fmt.Sprintf("%s %s %s", "How",
        "about",
        "this?"))