[SUGGESTION] More strict evaluation order of function parameters.

[mhermier]

This changes might fall under the "be more strict by default" umbrella.

As of current implementation, if I'm not mistaken in C++ std 7.6.1.3, the evaluation order of a parameter list is implementation specified. While it has no importance most of the time, it is not always true. In particular, it can have consequence in the lifetime of objects and more subtle unexpected behavior the compiler can't catch and can surprise the user. This issue can be mitigated by creating local variables, but can create more extra complications like requiring a copy/move constructor or adding more overloaded method calls.

I can see 2 solutions to this issue:

• Be more strict in the specification. While in practice, it should not have direct impact for the users, it can have in term of performance and call conventions. In term of tooling, it should help simplify compiler implementations and code check analysis.
• Provide an alternative syntax at call site to enforce evaluation order of the parameters. Considering the recent developments of the C++ language concerning constructors constructors initializer lists around the usage of {}, maybe it is a good candidate syntax. In term of tooling, it complexify the parsing/code analysis of a function calls, but also gives an opportunity to provide a unified evaluation of the parameter list convention . While a simpler compiler/analyzer/parser could simply treat both of them as ordered by default, it still let room for compilers to optionally bring performance (using -O flags ?).

[gregmarr]

I have a feeling that Herb mentioned this very briefly during his talk, perhaps even in the Q&A. I think it was under the idea of "everything is left to right".

[mhermier]

It is possible, at least it gives an entry to discuss about the subject. Since it is a sensible subject, about speed, calling conventions and possibly platform specific implications, it has to be thought carefully.

[hsutter]

Yes, I absolutely agree that evaluation of function arguments should be ordered left-to-right. I still hope today's C++ will do this.

Paper P0145R3, the paper to consistently improve order or evaluation across the language, was adopted in 2016 except only for this one part, left-to-right evaluation of function arguments. So I think it's time to bring this back to the ISO C++ committee, and I've pinged the coauthors about it. Why now? Because (a) time has passed and perhaps the main concerns some had back in 2016 about this might already be addressed, and (b) the ordering surprises also can lead to bugs that are security vulnerabilities and I think there's more of a sense of urgency about prioritizing fixing those now.

In terms of expr.call paragraph 8, I think the fix would be to change this

… The initialization of a parameter, including every associated value computation and side effect, is indeterminately sequenced with respect to that of any other parameter. …

to this

… The initialization of a parameter, including every associated value computation and side effect, is sequenced before that of any subsequent parameter. …

If today's C++ doesn't adopt this, I will probably have to implement it in cppfront. That's not too hard, but I'd rather do it in today's C++ syntax also so that we "light up" this benefit in all existing C++ code too.