Merge 2023-11 CWG Motion 1

P3046R0 Core Language Working Group "ready" Issues

Author: tkoeppe

source/basic.tex

@@ -1000,10 +1000,22 @@
 \pnum
 A declaration is \defnx{name-independent}{declaration!name-independent}
 if its name is \tcode{_} (\unicode{005f}{low line}) and it declares
+\begin{itemize}
+\item
 a variable with automatic storage duration,
-a structured binding not inhabiting a namespace scope,
+\item
+a structured binding
+%FIXME: "and" is strange below; maybe reword to something like:
+%FIXME: "that has no \grammarterm{storage-class-specifier} and
+%FIXME:  that is not inhabiting a namespace scope,"
+with no \grammarterm{storage-class-specifier} and
+not inhabiting a namespace scope,
+\item
 the variable introduced by an \grammarterm{init-capture}, or
-a non-static data member.
+\item
+%FIXME: "of" is strange below; remove it?
+a non-static data member of other than an anonymous union.
+\end{itemize}
 
 \recommended
 Implementations should not emit a warning
@@ -1278,7 +1290,7 @@
 \pnum
 If a declaration
 that is not a name-independent declaration and
-whose target scope is the block scope $S$ of a
+that binds a name in the block scope $S$ of a
 \begin{itemize}
 \item
 \grammarterm{compound-statement} of a \grammarterm{lambda-expression},
@@ -3300,6 +3312,12 @@
 standard-layout type\iref{basic.types.general} shall occupy contiguous bytes of
 storage.
 
+\pnum
+An object is a \defnadj{potentially non-unique}{object} if it is
+a string literal object\iref{lex.string},
+the backing array of an initializer list\iref{dcl.init.ref}, or
+a subobject thereof.
+
 \pnum
 \indextext{most derived object!bit-field}%
 \indextext{most derived object!zero size subobject}%
@@ -3308,11 +3326,13 @@
 Two objects
 with overlapping lifetimes
 that are not bit-fields
-may have the same address
-if one is nested within the other,
+may have the same address if
+\begin{itemize}
+\item one is nested within the other,
+\item at least one is a subobject of zero size and they are not of similar types\iref{conv.qual},
 or
-if at least one is a subobject of zero size
-and they are of different types;
+\item they are both potentially non-unique objects;
+\end{itemize}
 otherwise, they have distinct addresses
 and occupy disjoint bytes of storage.
 \begin{footnote}
@@ -3326,6 +3346,14 @@
 static const char test1 = 'x';
 static const char test2 = 'x';
 const bool b = &test1 != &test2;        // always \tcode{true}
+
+static const char (&r) [] = "x";
+static const char *s = "x";
+static std::initializer_list<char> il = { 'x' };
+const bool b2 = r != il.begin();        // unspecified result
+const bool b3 = r != s;                 // unspecified result
+const bool b4 = il.begin() != &test1;   // always \tcode{true}
+const bool b5 = r != &test1;            // always \tcode{true}
 \end{codeblock}
 \end{example}
 The address of a non-bit-field subobject of zero size is

source/classes.tex

@@ -796,9 +796,10 @@
 \item
 corresponding entities have the same alignment requirements\iref{basic.align},
 \item
-either both entities are declared with
-the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}
-or neither is, and
+if a \grammarterm{has-attribute-expression}\iref{cpp.cond}
+is not \tcode{0} for the \tcode{no_unique_address} attribute,
+then neither entity is declared with
+the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}, and
 \item
 either both entities are bit-fields with the same width
 or neither is a bit-field.
@@ -1095,7 +1096,9 @@
 \begin{itemize}
 \item the function is not deleted,
 \item the associated constraints\iref{temp.constr}, if any, are satisfied, and
-\item no special member function of the same kind is more constrained\iref{temp.constr.order}.
+\item no special member function of the same kind
+whose associated constraints, if any, are satisfied
+is more constrained\iref{temp.constr.order}.
 \end{itemize}
 
 \pnum
@@ -1983,9 +1986,8 @@
 shall be
 \keyword{friend},
 \keyword{inline},
-\keyword{virtual},
-\keyword{constexpr}, or
-\keyword{consteval}.
+\keyword{virtual}, or
+\keyword{constexpr}.
 
 \pnum
 \indextext{generated destructor|see{destructor, default}}%
@@ -2114,7 +2116,8 @@
 \tcode{X}
 calls the destructors for
 \tcode{X}'s
-direct non-variant non-static data members, the destructors for
+direct non-variant non-static data members other than anonymous unions,
+the destructors for
 \tcode{X}'s
 non-virtual direct base classes and, if
 \tcode{X}
@@ -3155,7 +3158,10 @@
 In an assignment expression of the form \tcode{E1 = E2}
 that uses either the built-in assignment operator\iref{expr.ass}
 or a trivial assignment operator\iref{class.copy.assign},
-for each element \tcode{X} of $S($\tcode{E1}$)$,
+for each element \tcode{X} of $S($\tcode{E1}$)$ and
+each anonymous union member \tcode{X}\iref{class.union.anon} that
+is a member of a union and
+has such an element as an immediate subobject (recursively),
 if modification of \tcode{X} would have undefined behavior under~\ref{basic.life},
 an object of the type of \tcode{X} is implicitly created
 in the nominated storage;
@@ -5818,9 +5824,16 @@
 were used to initialize the \tcode{D} object and
 each base class subobject from which the constructor was inherited,
 except that the \tcode{B} subobject is initialized
-by the invocation of the inherited constructor.
+by the inherited constructor
+if the base class subobject were to be initialized
+as part of the \tcode{D} object\iref{class.base.init}.
+The invocation of the inherited constructor,
+including the evaluation of any arguments,
+is omitted if the \tcode{B} subobject is not to be initialized
+as part of the \tcode{D} object.
 The complete initialization is considered to be a single function call;
-in particular, the initialization of the inherited constructor's parameters
+in particular, unless omitted,
+the initialization of the inherited constructor's parameters
 is sequenced before the initialization of any part of the \tcode{D} object.
 \begin{example}
 \begin{codeblock}
@@ -5870,6 +5883,23 @@
 whenever an object of class \tcode{Log} is destroyed.
 \end{example}
 
+\begin{example}
+\begin{codeblock}
+struct V { V() = default; V(int); };
+struct Q { Q(); };
+struct A : virtual V, Q {
+  using V::V;
+  A() = delete;
+};
+int bar() { return 42; }
+struct B : A {
+  B() : A(bar()) {} // OK
+};
+struct C : B {};
+void foo() { C c; } // \tcode{bar} is not invoked, because the \tcode{V} subobject is not initialized as part of \tcode{B}
+\end{codeblock}
+\end{example}
+
 \pnum
 If the constructor was inherited from multiple base class subobjects
 of type \tcode{B}, the program is ill-formed.

source/compatibility.tex

@@ -1826,6 +1826,27 @@
 revision of \Cpp{} because \tcode{double} to \tcode{int} is a narrowing
 conversion.
 
+\diffref{dcl.link}
+\change
+Names declared in an anonymous namespace
+changed from external linkage to internal linkage;
+language linkage applies to names with external linkage only.
+\rationale
+Alignment with user expectations.
+\effect
+Valid \CppIII{} code may violate the one-definition rule\iref{basic.def.odr}
+in this revision of \Cpp{}.
+For example:
+\begin{codeblock}
+namespace { extern "C" { extern int x; } }  // \#1, previously external linkage and C language linkage,
+                                            // now internal linkage and \Cpp{} language linkage
+namespace A { extern "C" int x = 42; }      // \#2, external linkage and C language linkage
+int main(void) { return x; }
+\end{codeblock}
+This code is valid in \CppIII{},
+but \tcode{\#2} is not a definition for \tcode{\#1}
+in this revision of \Cpp{}, violating the one-definition rule.
+
 \rSec2[diff.cpp03.class]{\ref{class}: classes}
 
 \diffref{class.default.ctor,class.dtor,class.copy.ctor,class.copy.assign}