[conv.qual] Adding const with pointers to arrays in the qualification-combined type

[Halalaluyafail3]

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

Reference (section label): [conv.qual]/3.3

Issue description:

Consider the type of 0?(int(*)[])0:(volatile int(*)[])0, the longest qualification-decomposition (n=2) for the types of both the second and the third operands should be:

• int(*)[]: cv_i¹ is empty for any i, P₀¹ is "pointer to", P₁¹ is "array of unknown bound of", and U₁ is the type int.
• volatile int(*)[]: cv₀² is empty, cv₁² and cv₂² are both volatile, P₀² is "pointer to", P₁² is "array of unknown bound of", and U₂ is the type int.

Following the rules of qualification-combined types:

• P₀³ is "pointer to", P₁³ is "array of unknown bound of", and U³ is the type int.
• cv₀³ is unspecified, cv₁³ is const volatile, and cv₂³ is volatile.

However, such a type cannot exist because it requires an array type that is const while its element type is not const. I believe the intent here is that const should not be added, otherwise it would be inconsistent with C. See also CWG2438.

Suggested resolution:

Modify [conv.qual]/3:

The qualification-combined type of two types T1 and T2 is the type T3 similar to T1 whose qualification-decomposition with the greatest value of n is such that:

• cv₀³ is empty,
• for every i>0, cv_i³ is the union of cv_i¹ and cv_i²,
• if either P_i¹ or P_i² is "array of unknown bound of", P_i³ is "array of unknown bound of", otherwise it is P_i¹, and
• if the resulting cv_i³ is different from cv_i¹ or cv_i², or the resulting P_i³ is different from P_i¹ or P_i², then const is added to every cv_k³ for 0<k<i≤l where l is the largest value such that 0≤l<i and P_l³ is neither "array of N_l³" nor "array of unknown bound of",

where cv_i^j and, P_i^j, and N_i^j are the components of the qualification-decomposition of T j. A prvalue of type T1 can be converted to type T2 if the qualification-combined type of T1 and T2 is T2.

This resolves points one and three of CWG2438. For point two, if U₁ and U₂ are different then those types are not similar. For point four, if either P_i¹ or P_i² is "array of unknown bound of" then the other must be "array of unknown bound of" or "array of N_i^other" for the types to be similar. For point five, if any changes are needed then those should be done in [expr.type]/3 where composite pointer type is defined.

[Halalaluyafail3]

Perhaps the following should also be added:

Modify [conv.qual]/1:

A qualification-decomposition of a type T is a sequence of cv_i and P_i such that T is

"cv₀ P₀ cv₁ P₁ ⋯ cv_n-1 P_n-1 cv_n U" for n ≥ 0,

where each cv_i is a set of cv-qualifiers ([basic.type.qualifier]), U is a cv-unqualified type, and each P_i is "pointer to" ([dcl.ptr]), "pointer to member of class C_i of type" ([dcl.mptr]), "array of N_i", or "array of unknown bounds of". If P_i designates an array, the cv-qualifiers cv_i+1 on the element type are also taken as the cv-qualifiers cv_i of the array.

Otherwise it appears that the type const int** in the following example could have a qualification-decomposition as n=2, P_i is "pointer to" for all i, cv_i is empty for all i, and U is the type const int. More importantly, it seems like the definition of qualification-combined types was not prepared to handle U being a cv-qualified type. For example, the qualification-combined type of int* and volatile int* being const volatile int* appears to be valid if U can be const int.

[Halalaluyafail3]

Note that with the above change to not allow U as a cv-qualified type, in the type const int(*)[] the following is still a valid qualification-decomposition: n=1, cv₀ is empty, P₀ is "pointer to", cv₁ is const, and U is the type int[].