[Motions 2026 06 cwg 1] P4271R0 Core Language Working Group "ready" Issues

source/basic.tex

@@ -2292,11 +2292,11 @@
 the innermost enclosing non-inline namespaces for its associated entities
 as well as every element of the inline namespace set\iref{namespace.def}
 of those namespaces.
-Argument-dependent lookup finds
-all declarations of functions and function templates that
+Argument-dependent lookup for a name $N$ finds
+all declarations of functions and function templates named $N$ that
 \begin{itemize}
 \item
-are found by a search of any associated namespace, or
+are found by a search for $N$ in any associated namespace, or
 \item
 are declared as a friend\iref{class.friend} of any class
 with a reachable definition in the set of associated entities, or
@@ -2307,7 +2307,7 @@
 have the same innermost enclosing non-inline namespace scope as
 a declaration of an associated entity attached to \tcode{M}\iref{basic.link}.
 \end{itemize}
-If the lookup is for a dependent name\iref{temp.dep,temp.dep.candidate},
+If $N$ is a dependent name\iref{temp.dep,temp.dep.candidate},
 the above lookup is also performed
 from each point in the instantiation context\iref{module.context} of the lookup,
 additionally ignoring any declaration that
@@ -3942,7 +3942,7 @@
 \item storage with the proper alignment and size
   for type \tcode{T} is obtained, and
 \item its initialization (if any) is complete
-  (including vacuous initialization)\iref{dcl.init},
+  (including vacuous initialization)\iref{dcl.init, class.base.init},
 \end{itemize}
 except that if the object is a union member or subobject thereof,
 its lifetime only begins if that union member is the
@@ -6270,8 +6270,8 @@
 Every integer type has an \term{integer conversion rank} defined as follows:
 
 \begin{itemize}
-\item No two signed integer types other than \keyword{char} and \tcode{\keyword{signed}
-\keyword{char}} (if \keyword{char} is signed) have the same rank, even if they have
+\item No two signed integer types
+have the same rank, even if they have
 the same representation.
 
 \item The rank of a signed integer type is greater than the rank
@@ -6289,18 +6289,12 @@
 \item The rank of any standard integer type is greater than the
 rank of any extended integer type with the same width.
 
-\item The rank of \keyword{char} equals the rank of \tcode{\keyword{signed} \keyword{char}}
-and \tcode{\keyword{unsigned} \keyword{char}}.
-
 \item The rank of \tcode{bool} is less than the rank of all
-standard integer types.
+other integer types.
 
 \item
-\indextext{type!\idxcode{wchar_t}}%
-\indextext{type!\idxcode{char16_t}}%
-\indextext{type!\idxcode{char32_t}}%
-The ranks of \keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, and
-\keyword{wchar_t} equal the ranks of their underlying
+The ranks of the character types
+equal the ranks of their corresponding underlying
 types\iref{basic.fundamental}.
 
 \item The rank of any extended signed integer type relative to another
@@ -6719,6 +6713,9 @@
 of subexpressions of individual expressions
 that are otherwise either unsequenced or indeterminately sequenced
 are evaluated in lexical order.
+For a function call\iref{expr.call},
+any default arguments used are evaluated in the order as if
+an argument were present for the corresponding parameter.
 
 \rSec2[intro.multithread]{Multi-threaded executions and data races}
 
@@ -7618,6 +7615,7 @@
 the initialization associated with the entity for thread \placeholder{t}
 is sequenced before the first non-initialization odr-use by \placeholder{t}
 of any non-inline variable with thread storage duration
+and dynamic initialization
 defined in the same translation unit as the variable to be initialized.
 It is \impldef{threads and program points at which deferred dynamic initialization is performed}
 in which threads and at which points in the program such deferred dynamic initialization occurs.

source/classes.tex

@@ -5621,8 +5621,6 @@
 class, thus its constructors never initialize virtual base classes, therefore the
 corresponding \grammarterm{mem-initializer}{s} can be omitted.
 \end{note}
-An attempt to initialize more than one non-static data member of a union renders the
-program ill-formed.
 \indextext{initialization!const member}%
 \indextext{initialization!reference member}%
 \begin{note}
@@ -5658,6 +5656,18 @@
 \end{codeblock}
 \end{example}
 
+\pnum
+An attempt to initialize more than one non-static data member of a union renders the
+program ill-formed.
+
+\pnum
+An object's initialization is considered complete when
+a non-delegating constructor for that object returns.
+\begin{note}
+Therefore, an object's lifetime can begin\iref{basic.life}
+before all delegating constructors have completed.
+\end{note}
+
 \pnum
 If a given non-static data member has both a default member initializer
 and a \grammarterm{mem-initializer}, the initialization specified by the
@@ -6073,7 +6083,7 @@
 \end{example}
 
 \pnum
-During the construction of an object,
+During the initialization of an object,
 if the value of any of its subobjects
 or any element of its object representation
 is accessed through a glvalue that is not obtained, directly or indirectly, from

source/compatibility.tex

@@ -547,6 +547,35 @@
 \end{codeblock}
 \end{example}
 
+\rSec2[diff.cpp20.over]{\ref{over}: overloading}
+
+\diffref{over.match.class.deduct}
+\change
+Deducing class template arguments from inherited constructors.
+\rationale
+Making class template argument deduction consistent with construction.
+\effect
+Valid ISO \CppXX{} code may become ill-formed or change meaning
+in this revision of \Cpp{}.
+\begin{example}
+\begin{codeblock}
+template<typename T>
+struct B {
+  B(T);
+};
+
+template<typename T>
+struct D : B<T *> {
+  D(T);
+  using B<T *>::B;
+  T m = "a";    // \#1
+};
+
+D d("");        // ill-formed at \#1 (\tcode{T} deduced as \tcode{const char});
+                // previously well-formed (\tcode{T} deduced as \tcode{const char*})
+\end{codeblock}
+\end{example}
+
 \rSec2[diff.cpp20.temp]{\ref{temp}: templates}
 
 \diffref{temp.deduct.type}
@@ -2992,6 +3021,43 @@
 \howwide
 Uncommon.
 
+\diffref{expr.arith.conv}
+\change
+The usual arithmetic conversions differ, between C and \Cpp{},
+in the treatment of enumeration types with no fixed underlying type.
+In \Cpp{}, values of such types are not specified
+as converting to the underlying type of the enumeration
+as part of the usual arithmetic conversions.
+Instead, integral promotions\iref{conv.prom}
+based on the values of the enumeration\iref{dcl.enum} are applied.
+\rationale
+Avoids the difference that can arise in C
+when replacing an enumeration constant in
+an expression with a cast of the same enumeration constant
+to the enumeration type.
+Allows \Cpp{} to treat an enumerator with behavior
+like that of \keyword{int}
+even while giving the enumerator the type of its enumeration.
+\effect
+Changes to semantics of well-defined feature.
+Some C expressions that have a dependence upon
+the implementation-defined
+underlying type of affected enumeration types
+will yield different results
+(as they would if a different underlying type
+is chosen by the C implementation).
+\begin{example}
+\begin{codeblock}
+typedef enum { E0 } E;      // the underlying type of \tcode{E} can be \tcode{unsigned int}
+static_assert(((E)E0 - 1 < 0) == (E0 - 1 < 0), "Must pass for C++");
+\end{codeblock}
+The \tcode{static_assert} may fail in C.
+\end{example}
+\difficulty
+Programs must add explicit casts to the underlying type.
+\howwide
+Rare.
+
 \diffref{expr.post.incr,expr.pre.incr}
 \change
 Decrement operator is not allowed with \keyword{bool} operand.