[intro.execution] p9 Are evaluations of these expressions that don't lexically appear in the full expression the associated evaluations of the full expression

[xmh0511]

Full name of submitter (unless configured in github; will be published with the issue): Jim X

Consider this example:

int value = 0;
void fun(){
  value = 1; // #1
}
int main(){
  fun(); // #2 
  value = 2; // #3
}

[intro.execution] p9 says:

Every value computation and side effect associated with a full-expression is sequenced before every value computation and side effect associated with the next full-expression to be evaluated.

In general, the associated evaluation of a full-expression refers to those of the expression that are part of the full-expression, and [intro.execution] p5 says

Conversions applied to the result of an expression in order to satisfy the requirements of the language construct in which the expression appears are also considered to be part of the full-expression. For an initializer, performing the initialization of the entity (including evaluating default member initializers of an aggregate) is also considered part of the full-expression.

The commonality of being part of the full-expression is that they lexically appear in the full-expression. For the above example, #1 doesn't syntactically appear in the full-expression at #2; is the evaluation of #1 the associated evaluation of the full-expression at #2?

A reasonable intent is that the evaluation at #1 is considered as an associated evaluation of the full-expression at #2 such that we can infer that #1 is sequenced-before #3.

Suggested Resolution:

[safocl]

A reasonable intent is that the evaluation at #1 is considered as an associated evaluation of the full-expression at #2 such that we can infer that #1 is sequenced-before #3.

int value = 0;
void fun(double){
  value = 3; // #1_1
}
void fun(int){
  value = 1; // #1_2
}
void fun(bool){
  value = 4; // #1_3
}

int runtime_selector(); // This returns a number that depends on the execution time.

int main(){
int i = runtime_selector();
if(i == 1)
  fun(double{});
else if (i == 2)
  fun(int{});
else
  fun(bool{});
  
value = 2; // #3
}

Which point from #1_N comes before point #3?
(Please forgive me for the pseudo-code in the example.)

[jensmaurer]

"evaluation" is a runtime concept. Please make your # annotations unique, and fix your function call syntax.

[safocl]

It just seems to me that the author wanted to say that, in his opinion, calling a function is the same as substituting the function body itself in place of its call, during execution, which is why the function body must be included in the expression itself in which the function is called.

int value = 0;
void fun(){
  value = 1; // #1
}
int main(){
  fun() /*{ value = 1; // #1}*/ ; // #2 
  value = 2; // #3
}

As far as I understand, this was done for reasons of "similarity" with some other entities that are included in "full-expression."
However, in my opinion, they are very different from the body of a function (which is not an immediate function), since, although "hidden" syntactically, they are actually present (the evaluation of default arguments, the predicate of a contract assertion, and others).
as in the following example:

int value = 0;
void fun(int = 5){
  value = 1; // #1
}
int main(){
  fun( /*5*/ ); // #2 
  value = 2; // #3
}