Merge 2019-11 CWG Motion 3

P1971R0 Core Language Changes for NB Comments

Author: zygoloid

source/basic.tex

@@ -2606,11 +2606,6 @@
     \opt{global-module-fragment} module-declaration \opt{top-level-declaration-seq} \opt{private-module-fragment}
 \end{bnf}
 
-\begin{bnf}
-\nontermdef{private-module-fragment}\br
-    \keyword{module} \terminal{:} \keyword{private} \terminal{;} \opt{top-level-declaration-seq}
-\end{bnf}
-
 \begin{bnf}
 \nontermdef{top-level-declaration-seq}\br
     top-level-declaration\br
@@ -2623,13 +2618,6 @@
     declaration
 \end{bnf}
 
-\pnum
-A \grammarterm{private-module-fragment} shall appear only
-in a primary module interface unit\iref{module.unit}.
-A module unit with a \grammarterm{private-module-fragment}
-shall be the only module unit of its module;
-no diagnostic is required.
-
 \pnum
 A token sequence beginning with
 \opt{\tcode{export}} \tcode{module}
@@ -2819,11 +2807,10 @@
 \item both names refer to members of the same namespace or to members,
 not by inheritance, of the same class; and
 
-\item when both names denote functions, the parameter-type-lists of the
-functions\iref{dcl.fct} are identical; and
+\item when both names denote functions or function templates,
+the signatures~(\ref{defns.signature}, \ref{defns.signature.templ})
+are the same.
 
-\item when both names denote function templates, the
-signatures\iref{temp.over.link} are the same.
 \end{itemize}
 If multiple declarations of the same name with external linkage
 would declare the same entity except that
@@ -3017,24 +3004,6 @@
 \item
 the new object is of the same type as \placeholder{e} (ignoring cv-qualification).
 \end{itemize}
-\begin{note}
-If the subobject contains a reference member or a \tcode{const} subobject,
-the name of the original subobject cannot be used to access the new object\iref{basic.life}.
-\end{note}
-\begin{example}
-\begin{codeblock}
-struct X { const int n; };
-union U { X x; float f; };
-void tong() {
-  U u = {{ 1 }};
-  u.f = 5.f;                            // OK, creates new subobject of \tcode{u}\iref{class.union}
-  X *p = new (&u.x) X {2};              // OK, creates new subobject of \tcode{u}
-  assert(p->n == 2);                    // OK
-  assert(*std::launder(&u.x.n) == 2);   // OK
-  assert(u.x.n == 2);                   // undefined behavior, \tcode{u.x} does not name new subobject
-}
-\end{codeblock}
-\end{example}
 
 \pnum
 \indextext{object!providing storage for}%
@@ -3359,9 +3328,9 @@
 \item the new object is of the same type as the original object
 (ignoring the top-level cv-qualifiers), and
 
-\item the type of the original object is not const-qualified, and, if a
-class type, does not contain any non-static data member whose type is
-const-qualified or a reference type, and
+\item the original object is neither
+a complete object that is const-qualified nor
+a subobject of such an object, and
 
 \item neither the original object nor the new object
 is a potentially-overlapping subobject\iref{intro.object}.
@@ -3696,13 +3665,13 @@
 \tcode{std::align_val_t},
 or any other names that the library uses to
 declare these names. Thus, a \grammarterm{new-expression},
-\grammarterm{delete-expression} or function call that refers to one of
-these functions without including the header \libheaderref{new} is
+\grammarterm{delete-expression}, or function call that refers to one of
+these functions without importing or including the header \libheaderref{new} is
 well-formed. However, referring to \tcode{std}
 or \tcode{std::size_t}
 or \tcode{std::align_val_t}
 is ill-formed unless the name has been declared
-by including the appropriate header.
+by importing or including the appropriate header.
 \end{note}
 Allocation and/or
 deallocation functions may also be declared and defined for any

source/declarations.tex

@@ -2174,7 +2174,7 @@
 The optional \grammarterm{requires-clause}\iref{temp} in an
 \grammarterm{init-declarator} or \grammarterm{member-declarator}
 shall not be present when the declarator does not declare a
-function\iref{dcl.fct}.
+templated function\iref{dcl.fct}.
 %
 \indextext{trailing requires-clause@trailing \textit{requires-clause}|see{\textit{requires-clause}, trailing}}%
 When present after a declarator, the \grammarterm{requires-clause}
@@ -2187,9 +2187,11 @@
 %
 \begin{example}
 \begin{codeblock}
-void f1(int a) requires true;               // OK
-auto f2(int a) -> bool requires true;       // OK
-auto f3(int a) requires true -> bool;       // error: \grammarterm{requires-clause} precedes \grammarterm{trailing-return-type}
+void f1(int a) requires true;               // error: non-templated function
+template<typename T>
+  auto f2(T a) -> bool requires true;       // OK
+template<typename T>
+  auto f3(T a) requires true -> bool;       // error: \grammarterm{requires-clause} precedes \grammarterm{trailing-return-type}
 void (*pf)() requires true;                 // error: constraint on a variable
 void g(int (*)() requires true);            // error: constraint on a \grammarterm{parameter-declaration}
 
@@ -5500,7 +5502,7 @@
 \end{note}
 The template
 \tcode{std::initializer_list} is not predefined; if the header
-\tcode{<initializer_list>} is not included prior to a use of
+\tcode{<initializer_list>} is not imported or included prior to a use of
 \tcode{std::initializer_list} --- even an implicit use in which the type is not
 named\iref{dcl.spec.auto} --- the program is ill-formed.
 
@@ -6251,10 +6253,12 @@
 \bnfindent promise-type \exposid{promise} promise-constructor-arguments \terminal{;}\br
 % FIXME: \bnfindent \exposid{promise}\terminal{.get_return_object()} \terminal{;}
 % ... except that it's not a discarded-value expression
-\bnfindent \terminal{co_await} \terminal{\exposid{promise}.initial_suspend()} \terminal{;}\br
 \bnfindent \terminal{try} \terminal{\{}\br
+\bnfindent\bnfindent \terminal{co_await} \terminal{\exposid{promise}.initial_suspend()} \terminal{;}\br
 \bnfindent\bnfindent function-body\br
 \bnfindent \terminal{\} catch ( ... ) \{}\br
+\bnfindent\bnfindent \terminal{if (!\exposid{initial-await-resume-called})}\br
+\bnfindent\bnfindent\bnfindent \terminal{throw} \terminal{;}\br
 \bnfindent\bnfindent \terminal{\exposid{promise}.unhandled_exception()} \terminal{;}\br
 \bnfindent \terminal{\}}\br
 \exposid{final-suspend} \terminal{:}\br
@@ -6272,6 +6276,12 @@
 the call to \tcode{final_suspend}
 is the \defn{final suspend point}, and
 \item
+\placeholder{initial-await-resume-called}
+is initially \tcode{false} and is set to \tcode{true}
+immediately before the evaluation
+of the \placeholder{await-resume} expression\iref{expr.await}
+of the initial suspend point, and
+\item
 \placeholder{promise-type} denotes the promise type, and
 \item
 the object denoted by the exposition-only name \exposid{promise}
@@ -7887,8 +7897,13 @@
 a function introduced by a \grammarterm{using-declaration}, and the
 declarations do not declare the same function, the program is
 ill-formed. If a function template declaration in namespace scope has
-the same name, parameter-type-list, return type, and template
-parameter list as a function template introduced by a
+the same
+name,
+parameter-type-list,
+trailing \grammarterm{requires-clause} (if any),
+return type, and
+\grammarterm{template-head},
+as a function template introduced by a
 \grammarterm{using-declaration}, the program is ill-formed.
 \begin{note}
 Two \grammarterm{using-declaration}{s} may introduce functions with the same
@@ -7924,8 +7939,13 @@
 When a \grammarterm{using-declarator} brings declarations from a base class into
 a derived class, member functions and member function templates in
 the derived class override and/or hide member functions and member
-function templates with the same name,
-parameter-type-list\iref{dcl.fct}, cv-qualification, and \grammarterm{ref-qualifier} (if any) in a base
+function templates with the same
+name,
+parameter-type-list\iref{dcl.fct},
+trailing \grammarterm{requires-clause} (if any),
+cv-qualification, and
+\grammarterm{ref-qualifier} (if any),
+in a base
 class (rather than conflicting).
 Such hidden or overridden declarations are excluded from the set of
 declarations introduced by the \grammarterm{using-declarator}.

source/expressions.tex

@@ -1324,12 +1324,14 @@
 is ill-formed.
 \begin{example}
 \begin{codeblock}
-void f(int) requires false;
+template<typename T> struct A {
+  static void f(int) requires false;
+}
 
 void g() {
-  f(0);                         // error: cannot call \tcode{f}
-  void (*p1)(int) = f;          // error: cannot take the address of \tcode{f}
-  decltype(f)* p2 = nullptr;    // error: the type \tcode{decltype(f)} is invalid
+  A<int>::f(0);                         // error: cannot call \tcode{f}
+  void (*p1)(int) = A<int>::f;          // error: cannot take the address of \tcode{f}
+  decltype(A<int>::f)* p2 = nullptr;    // error: the type \tcode{decltype(A<int>::f)} is invalid
 }
 \end{codeblock}
 In each case, the constraints of \tcode{f} are not satisfied.
@@ -3597,7 +3599,8 @@
 \end{example}
 
 \pnum
-If the header \libheaderrefx{typeinfo}{type.info} is not included prior
+If the header \libheaderrefx{typeinfo}{type.info}
+is not imported or included prior
 to a use of \tcode{typeid}, the program is ill-formed.
 
 \pnum
@@ -6007,7 +6010,7 @@
 \tcode{std::partial_ordering})
 are not predefined;
 if the header \libheaderref{compare}
-is not included prior to a use of such a class type --
+is not imported or included prior to a use of such a class type --
 even an implicit use in which the type is not named
 (e.g., via the \tcode{auto} specifier\iref{dcl.spec.auto}
 in a defaulted three-way comparison\iref{class.spaceship}
@@ -7132,31 +7135,36 @@
 
 \pnum
 For the purposes of determining
-whether an expression is a core constant expression,
+whether an expression \tcode{e} is a core constant expression,
 the evaluation of a call to a member function of \tcode{std::allocator<T>}
 as defined in \ref{allocator.members}, where \tcode{T} is a literal type,
-does not disqualify the expression from being a core constant expression,
+does not disqualify \tcode{e} from being a core constant expression,
 even if the actual evaluation of such a call
 would otherwise fail the requirements for a core constant expression.
 Similarly, the evaluation of a call to
 \tcode{std::destroy_at},
 \tcode{std::ranges::destroy_at},
 \tcode{std::construct_at}, or
 \tcode{std::ranges::construct_at}
-is a valid core constant expression unless:
+does not disqualify \tcode{e}
+from being a core constant expression unless:
 \begin{itemize}
 \item
   for a call to \tcode{std::construct_at} or \tcode{std::ranges::construct_at},
   the first argument, of type \tcode{T*},
-  does not point to storage allocated with \tcode{std::allocator<T>} or
+  does not point
+  to storage allocated with \tcode{std::allocator<T>} or
+  to an object whose lifetime began within the evaluation of \tcode{e}, or
   the evaluation of the underlying constructor call
-  is not a core constant expression, or
+  disqualifies \tcode{e} from being a core constant expression, or
 \item
   for a call to \tcode{std::destroy_at} or \tcode{std::ranges::destroy_at},
   the first argument, of type \tcode{T*},
-  does not point to storage allocated with \tcode{std::allocator<T>} or
+  does not point
+  to storage allocated with \tcode{std::allocator<T>} or
+  to an object whose lifetime began within the evaluation of \tcode{e}, or
   the evaluation of the underlying destructor call
-  is not a core constant expression.
+  disqualifies \tcode{e} from being a core constant expression.
 \end{itemize}
 
 \pnum

source/intro.tex

@@ -12,7 +12,7 @@
 
 \pnum
 \Cpp{} is a general purpose programming language based on the C
-programming language as described in ISO/IEC 9899:2011
+programming language as described in ISO/IEC 9899:2018
 \doccite{Programming languages --- C} (hereinafter referred to as the
 \defnx{C standard}{C!standard}). \Cpp{} provides many facilities
 beyond those provided by C, including additional data types,
@@ -47,7 +47,7 @@
 Vocabulary}
 \item ISO 8601:2004, \doccite{Data elements and interchange formats ---
 Information interchange --- Representation of dates and times}
-\item ISO/IEC 9899:2011, \doccite{Programming languages --- C}
+\item ISO/IEC 9899:2018, \doccite{Programming languages --- C}
 \item ISO/IEC 9945:2003, \doccite{Information Technology --- Portable
 Operating System Interface (POSIX)}
 \item ISO/IEC 10646, \doccite{Information technology ---
@@ -63,7 +63,7 @@
 \end{itemize}
 
 \pnum
-The library described in Clause 7 of ISO/IEC 9899:2011
+The library described in Clause 7 of ISO/IEC 9899:2018
 is hereinafter called the
 \defnx{C standard library}{C!standard library}.%
 \footnote{With the qualifications noted in \ref{\firstlibchapter}

source/modules.tex

@@ -529,10 +529,10 @@
 \end{example}
 
 \pnum
-A translation unit has an \defn{interface dependency} on a module unit \tcode{U}
+A translation unit has an \defn{interface dependency} on a translation unit \tcode{U}
 if it contains a \grammarterm{module-declaration} or
 \grammarterm{module-import-declaration} that imports \tcode{U} or if it has
-an interface dependency on a module unit that has an interface dependency on \tcode{U}.
+an interface dependency on a translation unit that has an interface dependency on \tcode{U}.
 A translation unit shall not have an interface dependency on itself.
 \begin{example}
 \begin{codeblocktu}{Interface unit of \tcode{M1}}
@@ -758,6 +758,75 @@
 \end{codeblocktu}
 \end{example}
 
+\rSec1[module.private.frag]{Private module fragment}
+
+\begin{bnf}
+\nontermdef{private-module-fragment}\br
+    \keyword{module} \terminal{:} \keyword{private} \terminal{;} \opt{top-level-declaration-seq}
+\end{bnf}
+
+\pnum
+A \grammarterm{private-module-fragment} shall appear only
+in a primary module interface unit\iref{module.unit}.
+A module unit with a \grammarterm{private-module-fragment}
+shall be the only module unit of its module;
+no diagnostic is required.
+
+\pnum
+\begin{note}
+A \grammarterm{private-module-fragment} ends
+the portion of the module interface unit
+that can affect the behavior of other translation units.
+A \grammarterm{private-module-fragment} allows a module
+to be represented as a single translation unit
+without making all of the contents of the module reachable to importers.
+The presence of a \grammarterm{private-module-fragment} affects:
+\begin{itemize}
+\item
+the point by which the definition of
+an exported inline function
+is required\iref{dcl.inline},
+
+\item
+the point by which the definition of
+an exported function with a placeholder return type
+is required\iref{dcl.spec.auto},
+
+\item
+the instantiation contexts of templates
+instantiated before it\iref{module.context}, and
+
+\item
+the reachability of declarations within it\iref{module.reach}.
+\end{itemize}
+\end{note}
+
+\pnum
+\begin{example}
+\begin{codeblock}
+export module A;
+export inline void fn_e();      // error: exported inline function \tcode{fn_e} not defined
+                                // before private module fragment
+inline void fn_m();             // OK, module-linkage inline function
+static void fn_s();
+export struct X;
+export void g(X *x) {
+  fn_s();                       // OK, call to static function in same translation unit
+  fn_m();                       // OK, call to module-linkage inline function
+}
+export X *factory();            // OK
+
+module :private;
+struct X {};                    // definition not reachable from importers of \tcode{A}
+X *factory() {
+   return new X ();
+}
+void fn_e() {}
+void fn_m() {}
+void fn_s() {}
+\end{codeblock}
+\end{example}
+
 \rSec1[module.context]{Instantiation context}
 
 \pnum