[std] Rephrase notes containing 'must'

Fixes ISO/CS 037 (C++23 DIS).

Author: jensmaurer

source/basic.tex

@@ -585,8 +585,8 @@
 \end{example}
 \begin{note}
 The rules for declarations and expressions
-describe in which contexts complete class types are required. A class
-type \tcode{T} must be complete if:
+describe in which contexts complete class types are required.
+The program is ill-formed unless a class type \tcode{T} is complete if:
 \begin{itemize}
 \item an object of type \tcode{T} is defined\iref{basic.def}, or
 \item a non-static class data member of type \tcode{T} is
@@ -4207,10 +4207,10 @@
 struct D : virtual B { char c; };
 \end{codeblock}
 
-When \tcode{D} is the type of a complete object, it will have a subobject of
-type \tcode{B}, so it must be aligned appropriately for a \tcode{\keyword{long} \keyword{double}}.
+When \tcode{D} is the type of a complete object, it has a subobject of
+type \tcode{B}, so it is aligned appropriately for a \tcode{\keyword{long} \keyword{double}}.
 If \tcode{D} appears as a subobject of another object that also has \tcode{B}
-as a virtual base class, the \tcode{B} subobject might be part of a different
+as a virtual base class, the \tcode{B} subobject can be part of a different
 subobject, reducing the alignment requirements on the \tcode{D} subobject.
 \end{example}
 The result of the \keyword{alignof} operator reflects the alignment
@@ -6368,7 +6368,7 @@
 \begin{note}
 The value observed by a load of an atomic depends on the ``happens
 before'' relation, which depends on the values observed by loads of atomics.
-The intended reading is that there must exist an
+The intended reading is that there exists an
 association of atomic loads with modifications they observe that, together with
 suitably chosen modification orders and the ``happens before'' relation derived
 as described above, satisfy the resulting constraints as imposed here.

source/classes.tex

@@ -435,9 +435,10 @@
 class A * A;
 \end{codeblock}
 first specifies \tcode{A} to be the name of a class and then redefines
-it as the name of a pointer to an object of that class. This means that
-the elaborated form \keyword{class} \tcode{A} must be used to refer to the
-class. Such artistry with names can be confusing and is best avoided.
+it as the name of a pointer to an object of that class.
+This means references to the class are ill-formed
+unless the elaborated form \keyword{class} \tcode{A} is used.
+Such artistry with names can be confusing and is best avoided.
 \end{note}
 
 \pnum
@@ -2226,7 +2227,7 @@
 \end{codeblock}
 \end{example}
 \begin{note}
-An explicit destructor call must always be written using
+An explicit destructor call is always written using
 a member access operator\iref{expr.ref} or a \grammarterm{qualified-id}\iref{expr.prim.id.qual};
 in particular, the
 \grammarterm{unary-expression}
@@ -3107,9 +3108,10 @@
 default constructor\iref{class.default.ctor},
 copy constructor, move constructor\iref{class.copy.ctor},
 copy assignment operator, move assignment operator\iref{class.copy.assign},
-or destructor\iref{class.dtor}, the corresponding member function
-of the union must be user-provided or it will
-be implicitly deleted\iref{dcl.fct.def.delete} for the union.
+or destructor\iref{class.dtor},
+the corresponding member function of the union
+will be implicitly deleted\iref{dcl.fct.def.delete}
+unless it is user-provided.
 \begin{example}
 Consider the following union:
 \begin{codeblock}
@@ -3123,8 +3125,8 @@
 member functions, \tcode{U} will have an implicitly deleted default constructor,
 copy/move constructor,
 copy/move assignment operator, and destructor.
-To use \tcode{U}, some or all of these member functions
-must be user-provided.
+A use \tcode{U} is ill-formed
+unless some or all of these member functions are user-provided.
 \end{example}
 \end{note}
 
@@ -4159,8 +4161,9 @@
   void draw();                  // a definition is required somewhere
 };
 \end{codeblock}
-would make class \tcode{circle} non-abstract and a definition of
-\tcode{circle::draw()} must be provided.
+would make class \tcode{circle} non-abstract;
+the program is ill-formed, no diagnostic required,
+unless a definition of \tcode{circle::draw()} is provided\iref{basic.def.odr}.
 \end{example}
 
 \pnum
@@ -4349,14 +4352,14 @@
 \tcode{A}.
 This implies, for example, that access checking on the first use of
 \tcode{A::I}
-must be deferred until it is determined that this use of
+is deferred until it is determined that this use of
 \tcode{A::I}
 is as the return type of a member of class
 \tcode{A}.
 Similarly, the use of \tcode{A::B} as a
 \grammarterm{base-specifier} is well-formed because \tcode{D}
 is derived from \tcode{A}, so checking of \grammarterm{base-specifier}{s}
-must be deferred until the entire \grammarterm{base-specifier-list} has been seen.
+is deferred until the entire \grammarterm{base-specifier-list} has been seen.
 \end{example}
 
 \pnum

source/declarations.tex

@@ -332,7 +332,7 @@
 
 void g(char c) {
   f(0);             // OK
-  f(c);             // error on implementations where \tcode{sizeof(int) > 1}: must be \tcode{int}-sized
+  f(c);             // error on implementations where \tcode{sizeof(int) > 1}: \tcode{must be int-sized}
 }
 \end{codeblock}
 \end{example}
@@ -1196,10 +1196,11 @@
 \pnum
 \begin{note}
 Declaring a variable \keyword{const} can affect its linkage\iref{dcl.stc}
-and its usability in constant expressions\iref{expr.const}. As
-described in~\ref{dcl.init}, the definition of an object or subobject
-of const-qualified type must specify an initializer or be subject to
-default-initialization.
+and its usability in constant expressions\iref{expr.const}.
+As described in~\ref{dcl.init},
+the definition of an object or subobject of const-qualified type is ill-formed
+unless the definition specifies an initializer or
+be subject to default-initialization.
 \end{note}
 
 \pnum
@@ -3595,10 +3596,9 @@
 printf("a=%d b=%d", a, b);
 \end{codeblock}
 
-However, the first argument must be of a type
-that can be converted to a
-\keyword{const}
-\tcode{char*}.
+However, the program is ill-formed
+unless the first argument is of a type
+that can be converted to a \keyword{const} \tcode{char*}.
 \end{example}
 \begin{note}
 The standard header \libheaderref{cstdarg}
@@ -4963,7 +4963,7 @@
 are the first $n$ elements of the aggregate,
 where $n$ is the number of elements in the initializer list.
 \item
-Otherwise, the initializer list must be \tcode{\{\}},
+Otherwise, the initializer list is \tcode{\{\}},
 and there are no explicitly initialized elements.
 \end{itemize}
 

source/expressions.tex

@@ -129,7 +129,7 @@
 required by the type; the types are not changed\
 thereby.
 \begin{footnote}
-The cast and assignment operators must still perform their specific
+The cast and assignment operators still perform their specific
 conversions as described in~\ref{expr.type.conv}, \ref{expr.cast},
 \ref{expr.static.cast} and~\ref{expr.ass}.
 \end{footnote}
@@ -479,7 +479,8 @@
 if the (possibly converted) expression is a prvalue of object type.
 \begin{note}
 If the original expression is an lvalue of class type,
-it must have a volatile copy constructor to initialize the temporary object
+the program is ill-formed unless
+the class has a volatile copy constructor to initialize the temporary object
 that is the result object of the temporary materialization conversion.
 \end{note}
 The expression is evaluated and its result (if any) is discarded.
@@ -716,7 +717,8 @@
 \tcode{T} shall be a complete type.
 \begin{note}
 If \tcode{T} is a class type (or array thereof),
-it must have an accessible and non-deleted destructor;
+the program is ill-formed
+unless the class has an accessible and non-deleted destructor;
 see~\ref{class.dtor}.
 \end{note}
 \begin{example}
@@ -2389,7 +2391,7 @@
 \end{itemize}
 \begin{note}
 This enables an \grammarterm{init-capture} like
-``\tcode{x = std::move(x)}''; the second ``\tcode{x}'' must bind to a
+``\tcode{x = std::move(x)}''; the second ``\tcode{x}'' binds to a
 declaration in the surrounding context.
 \end{note}
 \begin{example}
@@ -2628,7 +2630,7 @@
 If declared, such non-static data members shall be of literal type.
 \begin{example}
 \begin{codeblock}
-// The inner closure type must be a literal type regardless of how reference captures are represented.
+// The inner closure type is a literal type regardless of how reference captures are represented.
 static_assert([](int n) { return [&n] { return ++n; }(); }(3) == 4);
 \end{codeblock}
 \end{example}
@@ -4205,9 +4207,10 @@
 containing the original member, the resulting pointer to member points
 to the original member. Otherwise, the behavior is undefined.
 \begin{note}
-Although class \tcode{B} need not contain the original member, the
-dynamic type of the object with which indirection through the pointer
-to member is performed must contain the original member;
+Although class \tcode{B} need not contain the original member,
+the behavior is undefined
+if the dynamic type of the object with which indirection through the pointer
+to member is performed does not contain the original member;
 see~\ref{expr.mptr.oper}.
 \end{note}
 
@@ -4591,8 +4594,9 @@
 \indextext{type!incomplete}%
 Indirection through a pointer to an incomplete type (other than
 \cv{} \keyword{void}) is valid. The lvalue thus obtained can be
-used in limited ways (to initialize a reference, for example); this
-lvalue must not be converted to a prvalue, see~\ref{conv.lval}.
+used in limited ways (to initialize a reference, for example);
+the program is ill-formed
+if such an lvalue is converted to a prvalue, see~\ref{conv.lval}.
 \end{note}
 
 \pnum
@@ -5593,7 +5597,7 @@
 
 \pnum
 \begin{note}
-When the allocation function returns a value other than null, it must be
+When the allocation function returns a value other than null, it returns
 a pointer to a block of storage in which space for the object has been
 reserved. The block of storage is assumed to be
 appropriately aligned\iref{basic.align}
@@ -5778,9 +5782,10 @@
 \end{footnote}
 If not, the behavior is undefined.
 \begin{note}
-This means that the syntax of the \grammarterm{delete-expression} must
-match the type of the object allocated by \keyword{new}, not the syntax of the
-\grammarterm{new-expression}.
+This means that the behavior is undefined
+if the syntax of the \grammarterm{delete-expression} does not
+match the type of the object allocated by \keyword{new},
+regardless of the syntax of the \grammarterm{new-expression}.
 \end{note}
 \begin{note}
 A pointer to a \keyword{const} type can be the operand of a
@@ -7947,8 +7952,8 @@
 \begin{example}
 \begin{codeblock}
 bool f() {
-    char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
-    int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
+    char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Evaluated during translation
+    int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // Can be evaluated at runtime
     return sizeof(array) == size;
 }
 \end{codeblock}

source/modules.tex

@@ -824,7 +824,7 @@
 
 \item
 where definitions for inline functions and templates
-must appear\iref{basic.def.odr,dcl.inline,temp.pre},
+are required to appear\iref{basic.def.odr,dcl.inline,temp.pre},
 
 \item
 the instantiation contexts of templates

source/overloading.tex

@@ -11,7 +11,7 @@
 \indextext{function!overloaded|see{overloading}}%
 \begin{note}
 Each of two or more entities with the same name in the same scope,
-which must be functions or function templates,
+which are necessarily functions or function templates,
 is commonly called an ``overload''.
 \end{note}
 
@@ -1379,7 +1379,7 @@
 \pnum
 When resolving a placeholder for a deduced class type\iref{dcl.type.simple}
 where the \grammarterm{template-name} names an alias template \tcode{A},
-the \grammarterm{defining-type-id} of \tcode{A} must be of the form
+the \grammarterm{defining-type-id} of \tcode{A} is required to be of the form
 \begin{ncsimplebnf}
 \opt{\keyword{typename}} \opt{nested-name-specifier} \opt{\keyword{template}} simple-template-id
 \end{ncsimplebnf}

source/templates.tex

@@ -138,7 +138,8 @@
 \begin{note}
 Default arguments for function templates and for member functions of
 class templates are considered definitions for the purpose of template
-instantiation\iref{temp.decls} and must obey the one-definition rule\iref{basic.def.odr}.
+instantiation\iref{temp.decls} and
+thus are covered by the one-definition rule\iref{basic.def.odr}.
 \end{note}
 
 \pnum
@@ -2471,7 +2472,8 @@
 A member class of a class template may be defined outside the class template
 definition in which it is declared.
 \begin{note}
-The member class must be defined before its first use that requires
+The program is ill-formed
+if the member class is not defined before its first use that requires
 an instantiation\iref{temp.inst}.
 For example,
 \begin{codeblock}
@@ -3621,8 +3623,11 @@
 overload resolution of
 function template specializations
 with the same name.
-If such a non-template function is odr-used\iref{term.odr.use} in a program, it must be defined;
-it will not be implicitly instantiated using the function template definition.
+A program is ill-formed
+if such a non-template function is odr-used\iref{term.odr.use} in a program
+and there is no definition;
+the definition will not be implicitly instantiated
+using the function template definition.
 \end{footnote}
 
 \rSec3[temp.over.link]{Function template overloading}
@@ -6577,7 +6582,7 @@
 
 void h() {
   A<int> a;
-  a.f(16);          // \tcode{A<int>::f} must be defined somewhere
+  a.f(16);          // error: \tcode{A<int>::f} is not defined
 }
 
 // \tcode{\keyword{template}<>} not used for a member of an explicitly specialized class template
@@ -7755,9 +7760,9 @@
 is not used in any of the function parameters of a function template,
 or is used only in a non-deduced context, its corresponding
 \grammarterm{template-argument}
-cannot be deduced from a function call and the
-\grammarterm{template-argument}
-must be explicitly specified.
+cannot be deduced from a function call, and
+thus the program is ill-formed
+unless the \grammarterm{template-argument} is explicitly specified.
 \end{note}
 
 \pnum
@@ -8695,8 +8700,8 @@
 B<77>  b;
 
 int    x = deduce<77>(a.xm, 62, b.ym);
-// \tcode{T} deduced as \tcode{int}; \tcode{a.xm} must be convertible to \tcode{A<int>::X}
-// \tcode{i} is explicitly specified to be \tcode{77}; \tcode{b.ym} must be convertible to \tcode{B<77>::Y}
+// \tcode{T} deduced as \tcode{int}; \tcode{a.xm} is required to be convertible to \tcode{A<int>::X}
+// \tcode{i} is explicitly specified to be \tcode{77}; \tcode{b.ym} is required to be convertible to \tcode{B<77>::Y}
 \end{codeblock}
 \end{note}