CWG3100 Destruction order for objects with static storage duration

Fixes NB CA 045 (C++26 CD).

Author: eisenwave

source/basic.tex

@@ -7542,21 +7542,45 @@
 apply only to complete objects not having constant destruction.
 
 \pnum
-If the completion of the constructor or dynamic initialization of an object with static
-storage duration strongly happens before that of another, the completion of the destructor
-of the second is sequenced before the initiation of the destructor of the first.
-If the completion of the constructor or dynamic initialization of an object with thread
-storage duration is sequenced before that of another, the completion of the destructor
-of the second is sequenced before the initiation of the destructor of the first.
+If the deemed construction\iref{dcl.init.general} of a complete object with static
+storage duration strongly happens before that of another, the completion of the destruction
+of the second is sequenced before the initiation of the destruction of the first.
+If the deemed construction of a complete object with thread
+storage duration is sequenced before that of another, the completion of the destruction
+of the second is sequenced before the initiation of the destruction of the first.
 If an object is
 initialized statically, the object is destroyed in the same order as if
-the object was dynamically initialized. For an object of array or class
-type, all subobjects of that object are destroyed before any block
-variable with static storage duration initialized during the construction
-of the subobjects is destroyed.
+the object was dynamically initialized.
 If the destruction of an object with static or thread storage duration
 exits via an exception,
 the function \tcode{std::terminate} is called\iref{except.terminate}.
+\begin{example}
+In the following program,
+the elements of \tcode{a} are destroyed,
+followed by \tcode{dt}, and
+finally by the two \tcode{Btemp} objects:
+\begin{codeblock}
+struct DTemp { ~DTemp(); };
+struct Temp {
+  ~Temp() {
+    static DTemp dt;
+  }
+};
+struct BTemp {
+  ~BTemp();
+};
+struct A {
+  const BTemp &tb;
+  ~A();
+};
+A a[] = { (Temp(), BTemp()), BTemp() };
+
+int main() {}
+\end{codeblock}
+If the array \tcode{a} were an object with automatic storage duration,
+the \tcode{Btemp} temporaries would be destroyed
+as each element of the array is destroyed\iref{class.temporary}.
+\end{example}
 
 \pnum
 If a function contains a block variable of static or thread storage duration that has been
@@ -7572,12 +7596,13 @@
 \pnum
 \indextext{\idxcode{atexit}}%
 \indexlibraryglobal{atexit}%
-If the completion of the initialization of an object with static storage
+If the deemed construction of a complete object with static storage
 duration strongly happens before a call to \tcode{std::atexit}~(see
 \libheader{cstdlib}, \ref{support.start.term}), the call to the function passed to
-\tcode{std::atexit} is sequenced before the call to the destructor for the object. If a
-call to \tcode{std::atexit} strongly happens before the completion of the initialization of
-an object with static storage duration, the call to the destructor for the
+\tcode{std::atexit} is sequenced before the initiation of the destruction of the object.
+If a call to \tcode{std::atexit} strongly happens before the deemed construction of
+a complete object with static storage duration,
+the completion of the destruction of the
 object is sequenced before the call to the function passed to \tcode{std::atexit}. If a
 call to \tcode{std::atexit} strongly happens before another call to \tcode{std::atexit}, the
 call to the function passed to the second \tcode{std::atexit} call is sequenced before

source/declarations.tex

@@ -5437,8 +5437,13 @@
 \grammarterm{designated-initializer-list}.
 
 \pnum
-An object whose initialization has completed
-is deemed to be constructed,
+The \defnadj{deemed}{construction} of an object occurs when
+its initialization completes;
+for the purposes of~\ref{basic.start.term},
+if the initialization is a full-expression,
+deemed construction occurs when
+the evaluation of that full-expression completes.
+The object is deemed to be constructed,
 even if the object is of non-class type or
 no constructor of the object's class
 is invoked for the initialization.