[std] "must" fixes and suggested rewordings.

burblebee · zygoloid · commit 84087b3d3f0f · 2020-09-22T16:30:19.000-07:00
Partially addresses ISO/CS 017 (C++20 DIS).
diff --git a/source/basic.tex b/source/basic.tex
@@ -2509,7 +2509,7 @@
 \indextext{lookup!class member}%
 In a class member access expression\iref{expr.ref}, if the \tcode{.}
 or \tcode{->} token is immediately followed by an \grammarterm{identifier}
-followed by a \tcode{<}, the identifier must be looked up to determine
+followed by a \tcode{<}, the identifier is looked up to determine
 whether the \tcode{<} is the beginning of a template argument
 list\iref{temp.names} or a less-than operator. The identifier is first
 looked up in the class of the object expression\iref{class.member.lookup}.
@@ -3615,9 +3615,9 @@
 automatic storage duration, upon exit from the thread for an object with
 thread storage duration, or upon exit from the program for an object
 with static storage duration.}
-the program must ensure that an object of the original type occupies
+and another object of the original type does not occupy
 that same storage location when the implicit destructor call takes
-place; otherwise the behavior of the program is undefined. This is true
+place, the behavior of the program is undefined. This is true
 even if the block is exited with an exception.
 \begin{example}
 \begin{codeblock}
@@ -6157,7 +6157,7 @@
 programs cannot observe most program transformations that do not change
 single-threaded program semantics. In fact, most single-threaded program
 transformations continue to be allowed, since any program that behaves
-differently as a result must perform an undefined operation.
+differently as a result has undefined behavior.
 \end{note}
 
 \pnum
diff --git a/source/classes.tex b/source/classes.tex
@@ -3259,8 +3259,9 @@
 
 \pnum
 \begin{note}
-In general, one must use explicit destructor calls and placement
-\grammarterm{new-expression} to change the active member of a union.
+In cases where the above rule does not apply,
+the active member of a union can only be changed by
+the use of a placement \grammarterm{new-expression}.
 \end{note}
 \begin{example}
 Consider an object \tcode{u} of a \tcode{union} type \tcode{U} having non-static data members
diff --git a/source/compatibility.tex b/source/compatibility.tex
@@ -2039,7 +2039,7 @@
 
 \diffref{expr.sizeof,expr.cast}
 \change
-Types must be defined in declarations, not in expressions.\\
+In \Cpp{}, types can only be defined in declarations, not in expressions.\\
 In C, a sizeof expression or cast expression may define a new type.
 For example,
 \begin{codeblock}
@@ -2637,8 +2637,6 @@
 \Cpp{} is not identical to ISO C\@.
 Mandating that \mname{STDC}
 be defined would require that translators make an incorrect claim.
-Each implementation must choose the behavior that will be most
-useful to its marketplace.
 \effect
 Change to semantics of well-defined feature.
 \difficulty
diff --git a/source/containers.tex b/source/containers.tex
@@ -4079,8 +4079,9 @@
 \begin{note}
 Modifying any list requires access to the element preceding the first element
 of interest, but in a \tcode{forward_list} there is no constant-time way to access a
-preceding element. For this reason, ranges that are modified, such as those supplied to
-\tcode{erase} and \tcode{splice}, must be open at the beginning.
+preceding element.
+For this reason, \tcode{erase_after} and \tcode{splice_after}
+take fully-open ranges, not semi-open ranges.
 \end{note}
 
 \begin{codeblock}
diff --git a/source/exceptions.tex b/source/exceptions.tex
@@ -989,7 +989,8 @@
 
 \pnum
 \indextext{\idxcode{terminate}}%
-In some situations exception handling must be abandoned
+% FIXME: What does it mean to abandon exception handling?
+In some situations exception handling is abandoned
 for less subtle error handling techniques.
 \begin{note}
 These situations are:
diff --git a/source/expressions.tex b/source/expressions.tex
@@ -6437,12 +6437,12 @@
 \begin{itemize}
 \item If \tcode{E2} is an lvalue, the target type is
 ``lvalue reference to \tcode{T2}'', subject to the
-constraint that in the conversion the reference must bind
+constraint that in the conversion the reference binds
 directly\iref{dcl.init.ref} to a glvalue.
 
 \item If \tcode{E2} is an xvalue, the target type is
 ``rvalue reference to \tcode{T2}'',
-subject to the constraint that the reference must bind directly.
+subject to the constraint that the reference binds directly.
 
 \item If \tcode{E2} is a prvalue or if neither of the conversion sequences above can be
 formed and at least one of the operands has (possibly cv-qualified) class type:
@@ -6617,8 +6617,8 @@
 no new exception object is created.
 The exception is no longer considered to be caught.
 \begin{example}
-Code that must be executed because of an exception, but cannot
-completely handle the exception itself, can be written like this:
+An exception handler that cannot completely handle the exception itself
+can be written like this:
 \begin{codeblock}
 try {
   // ...
diff --git a/source/grammar.tex b/source/grammar.tex
@@ -10,8 +10,8 @@
 In particular, the grammar described here accepts
 a superset of valid \Cpp{} constructs.
 Disambiguation rules~(\ref{stmt.ambig}, \ref{dcl.spec}, \ref{class.member.lookup})
-must be applied to distinguish expressions from declarations.
-Further, access control, ambiguity, and type rules must be used
+are applied to distinguish expressions from declarations.
+Further, access control, ambiguity, and type rules are used
 to weed out syntactically valid but meaningless constructs.
 
 \rSec1[gram.key]{Keywords}
diff --git a/source/iostreams.tex b/source/iostreams.tex
@@ -465,7 +465,8 @@
 \pnum
 Concurrent access to a synchronized\iref{ios.members.static} standard iostream object's formatted and unformatted input\iref{istream} and output\iref{ostream} functions or a standard C stream by multiple threads does not result in a data race\iref{intro.multithread}.
 \begin{note}
-Users must still synchronize concurrent use of these objects and streams by multiple threads if they wish to avoid interleaved characters.
+Unsynchronized concurrent use of these objects and streams by multiple threads
+can result in interleaved characters.
 \end{note}
 
 \xrefc{7.21.2}
@@ -13550,9 +13551,6 @@
 \tcode{equivalent("foo", "bar")} will be \tcode{true} when both paths resolve to the same file.
 \end{example}
 \end{itemize}
-Programmers wishing to determine if two paths are ``the same'' must decide if
-  ``the same'' means ``the same representation'' or ``resolve to the same actual
-  file'', and choose the appropriate function accordingly.
 \end{note}
 \end{itemdescr}
 
@@ -14251,8 +14249,7 @@
 \begin{note}
 Implementations of \tcode{directory_iterator}\iref{fs.class.directory.iterator}
 are prohibited from directly or indirectly calling the \tcode{refresh} function
-since it must access the external file system,
-and the objective of caching is to avoid unnecessary file system accesses.
+as described in \ref{fs.class.directory.iterator.general}.
 \end{note}
 \end{itemdescr}
 
diff --git a/source/iterators.tex b/source/iterators.tex
@@ -566,11 +566,6 @@
 The library never assumes that past-the-end values are dereferenceable.
 Iterators can also have singular values that are not associated with any
 sequence.
-\begin{example}
-After the declaration of an uninitialized pointer \tcode{x}
-(as with \tcode{int* x;}),
-\tcode{x} must always be assumed to have a singular value of a pointer.
-\end{example}
 Results of most expressions are undefined for singular values;
 the only exceptions are destroying an iterator that holds a singular value,
 the assignment of a non-singular value to
diff --git a/source/locales.tex b/source/locales.tex
@@ -2053,11 +2053,11 @@
 \tcode{ok}.\footnote{Informally, this means that
 \tcode{basic_filebuf}
 assumes that the mappings from internal to external characters is
-1 to N: a
+1 to N: that a
 \tcode{codecvt}
 facet that is used by
 \tcode{basic_filebuf}
-must be able to translate characters one internal character at a time.
+can translate characters one internal character at a time.
 }
 \begin{note}
 As a result of operations on \tcode{state}, it can return \tcode{ok} or \tcode{partial} and set \tcode{from_next == from} and \tcode{to_next != to}.
diff --git a/source/overloading.tex b/source/overloading.tex
@@ -838,7 +838,7 @@
 a contrived object of type
 \tcode{T}
 becomes the implied object
-argument.\footnote{An implied object argument must be contrived to
+argument.\footnote{An implied object argument is contrived to
 correspond to the implicit object
 parameter attributed to member functions during overload resolution.
 It is not
@@ -3352,7 +3352,7 @@
 and
 \tcode{g()}
 are both overloaded functions, the
-cross product of possibilities must be considered
+Cartesian product of possibilities is considered
 to resolve
 \tcode{f(\&g)},
 or the equivalent expression
diff --git a/source/statements.tex b/source/statements.tex
@@ -1005,10 +1005,15 @@
 declaration.
 If control enters the declaration concurrently while the variable is
 being initialized, the concurrent execution shall wait for completion
-of the initialization.\footnote{The implementation must not introduce
-any deadlock around execution of the initializer. Deadlocks might
-still be caused by the program logic; the implementation need only
-avoid deadlocks due to its own synchronization operations.} If control
+of the initialization.
+\begin{note}
+A conforming implementation cannot introduce
+any deadlock around execution of the initializer.
+Deadlocks might still be caused by the program logic;
+the implementation need only avoid deadlocks
+due to its own synchronization operations.
+\end{note}
+If control
 re-enters the declaration recursively while
 the variable is being initialized, the behavior is undefined.
 \begin{example}
diff --git a/source/templates.tex b/source/templates.tex
@@ -694,31 +694,18 @@
   id-expression
 \end{bnf}
 
-\begin{note}
-The name lookup rules\iref{basic.lookup} are used to associate the use of
-a name with a template declaration;
-that is, to identify a name as a
-\grammarterm{template-name}.
-\end{note}
-
 \pnum
-For a
-\grammarterm{template-name}
-to be explicitly qualified by the template arguments,
-the name must be considered to refer to a template.
+An \grammarterm{identifier} is a \grammarterm{template-name}
+if it is associated by name lookup with
+a template or an overload set that contains a function template, or
+the \grammarterm{identifier} is followed by \tcode{<},
+the \grammarterm{template-id} would form an \grammarterm{unqualified-id}, and
+name lookup either finds one or more functions or finds nothing.
 \begin{note}
 Whether a name actually refers to a template
 cannot be known in some cases
 until after argument dependent lookup is done\iref{basic.lookup.argdep}.
 \end{note}
-A name is considered to refer to a template if
-name lookup finds
-a \grammarterm{template-name}
-or an overload set that contains a function template.
-A name is also considered to refer to a template if
-it is an \grammarterm{unqualified-id}
-followed by a \tcode{<}
-and name lookup either finds one or more functions or finds nothing.
 
 \pnum
 \indextext{\idxcode{<}!template and}%
@@ -4642,7 +4629,7 @@
 is the standard output stream declared in
 \tcode{iostream}.
 However, not every declaration can be found this way; the resolution of
-some names must be postponed
+some names is postponed
 until the actual
 \grammarterm{template-argument}{s}
 are known.
@@ -7132,12 +7119,13 @@
 otherwise, it is a declaration.
 \begin{note}
 The definition of a static data member of a template
-that requires default-initialization must use a \grammarterm{braced-init-list}:
+for which default-initialization is desired
+can use functional cast notation\iref{expr.type.conv}:
 
 \begin{codeblock}
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
-template<> X Q<int>::x { };                     // definition
+template<> X Q<int>::x = X();                   // definition
 \end{codeblock}
 \end{note}
 
diff --git a/source/threads.tex b/source/threads.tex
@@ -93,8 +93,8 @@
 \pnum
 The functions whose names end in \tcode{_for} take an argument that
 specifies a duration. These functions produce relative timeouts. Implementations
-should use a steady clock to measure time for these functions.\footnote{All
-implementations for which standard time units are meaningful must necessarily
+should use a steady clock to measure time for these functions.%
+\footnote{Implementations for which standard time units are meaningful will typically
 have a steady clock within their hardware implementation.} Given a duration
 argument $D_t$, the real-time duration of the timeout is $D_t + D_i + D_m$.
 
@@ -1271,8 +1271,9 @@
 \begin{note}
 Either implicitly detaching or joining a \tcode{joinable()} thread in its
 destructor could result in difficult to debug correctness (for detach) or performance
-(for join) bugs encountered only when an exception is thrown. Thus the programmer must
-ensure that the destructor is never executed while the thread is still joinable.
+(for join) bugs encountered only when an exception is thrown.
+These bugs can be avoided by ensuring that
+the destructor is never executed while the thread is still joinable.
 \end{note}
 \end{itemdescr}
 
@@ -4029,7 +4030,7 @@
 not result in deadlock, but is otherwise unspecified.
 \begin{note}
 A deadlock avoidance
-algorithm such as try-and-back-off must be used, but the specific algorithm is not
+algorithm such as try-and-back-off can be used, but the specific algorithm is not
 specified to avoid over-constraining implementations.
 \end{note}
 If a call to
