Temporary materialization conversion is not array-to-pointer decay, but the former can be a part of the latter. I'm not sure if anything needs clarification.

In the following example,

using A = int[1];
+A{0};

1. the prvalue of type int[1] (A{0}) is converted to xvalue (a temporary object is created);
2. a prvalue of type int* is produced, which points to the first element of the temporary array object.

IIUC, temporary materialization conversion only consists of 1, while array-to-pointer decay consists of 1 and 2.

The temporary materialization conversion (7.3.5) is applied.

All this is saying is that if you have an array prvalue, then it is materialized, i.e. you have a glvalue to whose first element you can then point. I'm not sure if any of this needs clarification?

Temporary materialization conversion is not array-to-pointer decay, but the former can be a part of the latter. I'm not sure if anything needs clarification.

Thank you for the response! Yes, I completely agree that they are separate and that one (array-to-pointer decay) uses the other (temporary materialization conversion) in certain cases.

In the following example,

using A = int[1];
+A{0};

1. the prvalue of type `int[1]` (`A{0}`) is converted to xvalue (a temporary object is created);

It is my understanding that it would be here that temporary materialization would take place. That seems to correspond to your understanding as well ... whew! :-)

I think in this example there are more than one temporary conversions happening and only one of them comes from the array-to-pointer decay. I think that (1) is a temporary materialization that is unrelated to the one defined in [conv.array].

2. a prvalue of type `int*` is produced, which points to the first element of the temporary array object.

I think that it would be here that the [conv.array] language comes in to play. Because we are doing + that means that we need the operand to be something +able and so the xvalue from (1) (of type int[1]) will "decay to pointer". As I continue to read the second [conv.array], we have here " “array of N T”... [that should be] converted to a prvalue of
type “pointer to T” ". Again, in my feeble attempt at understanding, I read [conv.array] to say that process occurs through temporary materialization conversion.

And this is where I get confused.

If my reading is correct, then, what goes in to temporary materialization conversion (a prvalue of type T) is akin what comes out (an xvalue of type T). But, in the situation we have here, what goes in is a prvalue of array of N T (where N is 1 and T is int) and what comes out is not an xvalue of array of N T (it is supposed to have the type of "pointer to the first element of the array").

Again, I am sure that I am misunderstanding something, but that is how I am reading it.

Thank you and @tkoeppe for the discussion! I hope that this discussion is helpful!

Will

IIUC, temporary materialization conversion only consists of 1, while array-to-pointer decay consists of 1 and 2.

In the following example,

using A = int[1];
+A{0};

1. the prvalue of type `int[1]` (`A{0}`) is converted to xvalue

This is just ill-formed. Or, you can say, this is CWG2548, which, in turn, should be closed as NAD confirming that ill-formedness is intended.