Is the order of function argument evaluation stable?

[felixrabe]

So I’m just watching https://www.youtube.com/watch?v=69pvUyBsruQ&t=2h15m19s and Simon Carter is referencing a difference between C compilers / platforms in the order of evaluating function arguments. So this makes me wonder:

Is this order defined in Zig? Is the following guaranteed?

functionCall(evaluatedFirst(), evaluatedSecond());

See also:

• https://search.brave.com/search?q=zig+function+argument+evaluation+order
• In-Depth Technical Guide to Zig Functions – Murat Genc states: “Arguments are pushed onto the stack from right to left.”

[Sze]

Does Zig guarantee left-to-right order of evaluation?

Does Zig guarantee left-to-right order of evaluation? For example, in an expression like f() + g() or a statement like f().* = g(); will f() be called before g()? This is guaranteed in many languages, but notably not in C or C++. Based on Zig’s design principles, I would guess that Zig does guarantee this, but I couldn’t find an explicit statement along those lines in the language spec.

[felixrabe]

Thanks. That’s related, but does not seem to address the evaluation order of function arguments.

For instance, C’s comma operator , is defined as a sequence point

I did a quick search - “comma operator” is not referring to the comma used for delimiting function arguments.

[Sze]

The part about the comma operator is talking about C, I think this part is more relevant:

@mlugg

As such, whilst I do not know if it has been formally defined at any point, I do expect Zig to ultimately include the status quo behavior in its spec, where sequencing of side effects always happens in the order of the source code (which I can confirm is guaranteed in the current compiler implementation, and in fact would be quite difficult for us to change due to how the compiler pipeline is structured).

[dupdrop]

I’m fairly sure it’s well defined to evaluate left-to-right. (But I didn’t find it in a quick search in the language reference, so could be wrong)

Your post reminded me to look at this issue regarding the evaluation order of operators like += etc: Proposal: Load `lhs` after `rhs` is executed for assignment operators like `+=` · Issue #25315 · ziglang/zig · GitHub

… which is surprisingly non-obvious.

[Cloudef]

Considering field initialization order in zig is well defined, it would make sense function argument evaluation order would be too, considering @call is a thing and accepts args as tuple.
I hope the langref makes it clear at some point.