Merge 2018-03 CWG Motion 1

Author: zygoloid

source/basic.tex

@@ -1141,16 +1141,18 @@
 \indextext{scope name hiding and}%
 \indextext{name hiding}%
 \indextext{hiding|see{name hiding}}%
-A name can be hidden by an explicit declaration of that same name in a
-nested declarative region or derived class\iref{class.member.lookup}.
+A declaration of a name in a nested declarative region
+hides a declaration of the same name in an enclosing declarative region;
+see \ref{basic.scope.declarative} and \ref{basic.lookup.unqual}.
 
 \pnum
 \indextext{name hiding}%
-A class name\iref{class.name} or enumeration name\iref{dcl.enum} can
-be hidden by the name of a variable, data member, function, or enumerator declared in
-the same scope. If a class or enumeration name and a variable, data member, function,
-or enumerator are declared in the same scope (in any order) with the
-same name, the class or enumeration name is hidden wherever the variable, data member,
+If a class name\iref{class.name} or enumeration name\iref{dcl.enum} and
+a variable, data member, function, or enumerator
+are declared in the same declarative region (in any order) with the
+same name (excluding declarations made visible
+via \grammarterm{using-directive}{s}\iref{basic.lookup.unqual}),
+the class or enumeration name is hidden wherever the variable, data member,
 function, or enumerator name is visible.
 
 \pnum
@@ -2470,21 +2472,12 @@
 \item it is a cv-qualified\iref{basic.type.qualifier} version of a
 type that has linkage.
 \end{itemize}
-A type without linkage shall not be used as the type of a variable or
-function with external linkage unless
-\begin{itemize}
-\item the entity has C language linkage\iref{dcl.link}, or
-
-\item the entity is not odr-used\iref{basic.def.odr} or is defined in
-the same translation unit.
-\end{itemize}
 \begin{note}
 In other words, a type without linkage contains a class or enumeration that
-cannot be named outside its translation unit. An entity with external linkage declared
-using such a type could not correspond to any other entity in another translation unit
-of the program and thus must be defined in the
-translation unit if it is odr-used. Also note that classes with linkage may contain members
-whose types do not have linkage, and that typedef names are ignored in the determination
+cannot be named outside its translation unit.
+Classes with linkage may contain members
+whose types do not have linkage.
+Typedef names are ignored in the determination
 of whether a type has linkage.
 \end{note}
 
@@ -2501,7 +2494,7 @@
   A a = { 1 };
   B<A> ba;              // declares \tcode{B<A>::g(A)} and \tcode{B<A>::h(A)}
   ba.g(a);              // OK
-  ba.h(a);              // error: \tcode{B<A>::h(A) not defined in the translation unit}
+  ba.h(a);              // error: \tcode{B<A>::h(A)} not defined; \tcode{A} cannot be named in another translation unit
   i(ba, a);             // OK
 }
 \end{codeblock}
@@ -3236,10 +3229,11 @@
 class\iref{class.free}.
 
 \pnum
-Any allocation and/or deallocation functions defined in a \Cpp{} program,
-including the default versions in the library, shall conform to the
-semantics specified in~\ref{basic.stc.dynamic.allocation}
-and~\ref{basic.stc.dynamic.deallocation}.
+If the behavior of an allocation or deallocation function
+does not satisfy the semantic constraints
+specified in~\ref{basic.stc.dynamic.allocation}
+and~\ref{basic.stc.dynamic.deallocation},
+the behavior is undefined.
 
 \rSec4[basic.stc.dynamic.allocation]{Allocation functions}
 
@@ -3251,37 +3245,41 @@
 global scope. The return type shall be \tcode{void*}. The first
 parameter shall have type \tcode{std::size_t}\iref{support.types}. The
 first parameter shall not have an associated default
-argument\iref{dcl.fct.default}. The value of the first parameter shall
-be interpreted as the requested size of the allocation. An allocation
+argument\iref{dcl.fct.default}. The value of the first parameter
+is interpreted as the requested size of the allocation. An allocation
 function can be a function template. Such a template shall declare its
 return type and first parameter as specified above (that is, template
 parameter types shall not be used in the return type and first parameter
 type). Template allocation functions shall have two or more parameters.
 
 \pnum
-The allocation function attempts to allocate the requested amount of
-storage. If it is successful, it shall return the address of the start
-of a block of storage whose length in bytes shall be at least as large
-as the requested size. There are no constraints on the contents of the
-allocated storage on return from the allocation function. The order,
+An allocation function attempts to allocate the requested amount of
+storage. If it is successful, it returns the address of the start
+of a block of storage whose length in bytes is at least as large
+as the requested size.
+The order,
 contiguity, and initial value of storage allocated by successive calls
-to an allocation function are unspecified. The pointer returned shall be
+to an allocation function are unspecified.
+For an allocation function other than
+a reserved placement allocation function\iref{new.delete.placement},
+the pointer returned is
 suitably aligned so that it can be converted to a pointer to any
 suitable complete object type\iref{new.delete.single}
 and then used to access the object or array in the
 storage allocated (until the storage is explicitly deallocated by a call
 to a corresponding deallocation function). Even if the size of the space
 requested is zero, the request can fail. If the request succeeds, the
-value returned shall be a non-null pointer value\iref{conv.ptr}
+value returned by a replaceable allocation function
+is a non-null pointer value\iref{conv.ptr}
 \tcode{p0} different from any previously returned value \tcode{p1},
-unless that value \tcode{p1} was subsequently passed to an
-\tcode{operator} \tcode{delete}.
+unless that value \tcode{p1} was subsequently passed to a
+replaceable deallocation function.
 Furthermore, for the library allocation functions
 in~\ref{new.delete.single} and~\ref{new.delete.array},
-\tcode{p0} shall represent the address of a block of storage disjoint from the storage
+\tcode{p0} represents the address of a block of storage disjoint from the storage
 for any other object accessible to the caller.
 The effect of indirecting through a pointer
-returned as a request for zero size is undefined.\footnote{The intent is
+returned from a request for zero size is undefined.\footnote{The intent is
 to have \tcode{operator new()} implementable by
 calling \tcode{std::malloc()} or \tcode{std::calloc()}, so the rules are
 substantially the same. \Cpp{} differs from C in requiring a zero request
@@ -3295,11 +3293,13 @@
 A program-supplied allocation function can obtain the address of the
 currently installed \tcode{new_handler} using the
 \tcode{std::get_new_handler} function\iref{set.new.handler}. \end{note}
-If an allocation function that has a non-throwing
+An allocation function that has a non-throwing
 exception specification\iref{except.spec}
-fails to allocate storage, it shall return a null pointer. Any other
-allocation function that fails to allocate storage shall indicate
-failure only by throwing an exception\iref{except.throw} of a type
+indicates failure by returning
+a null pointer value.
+Any other allocation function
+never returns a null pointer value and
+indicates failure only by throwing an exception\iref{except.throw} of a type
 that would match a handler\iref{except.handle} of type
 \tcode{std::bad_alloc}\iref{bad.alloc}.
 

source/classes.tex

@@ -55,6 +55,10 @@
     \terminal{union}
 \end{bnf}
 
+A class declaration where the \grammarterm{class-name}
+in the \grammarterm{class-head-name} is a \grammarterm{simple-template-id}
+shall be an explicit specialization\iref{temp.expl.spec} or
+a partial specialization\iref{temp.class.spec}.
 A \grammarterm{class-specifier} whose
 \grammarterm{class-head} omits the
 \grammarterm{class-head-name} defines an unnamed class. \begin{note} An unnamed class thus can't
@@ -637,7 +641,7 @@
 A \grammarterm{virt-specifier-seq} shall contain at most one of each
 \grammarterm{virt-specifier}.
 A \grammarterm{virt-specifier-seq}
-shall appear only in the declaration of a virtual member
+shall appear only in the first declaration of a virtual member
 function\iref{class.virtual}.
 
 \pnum
@@ -1330,6 +1334,7 @@
 A declaration for a bit-field that omits the \grammarterm{identifier}
 declares an \defn{unnamed bit-field}. Unnamed bit-fields are not
 members and cannot be initialized.
+An unnamed bit-field shall not be declared with a cv-qualified type.
 \begin{note}
 An unnamed bit-field is useful for padding to conform to
 externally-imposed layouts.

source/compatibility.tex

@@ -873,7 +873,7 @@
 this International Standard. Specifically, macros named \tcode{R}, \tcode{u8},
 \tcode{u8R}, \tcode{u}, \tcode{uR}, \tcode{U}, \tcode{UR}, or \tcode{LR} will
 not be expanded when adjacent to a string literal but will be interpreted as
-part of the string literal. For example,
+part of the string literal. For example:
 
 \begin{codeblock}
 #define u8 "abc"
@@ -885,7 +885,8 @@
 \rationale Required for new features.
 \effect
 Valid \CppIII{} code may fail to compile or produce different results in
-this International Standard, as the following example illustrates.
+this International Standard.
+For example:
 
 \begin{codeblock}
 #define _x "there"
@@ -929,7 +930,8 @@
 \rationale Removing surprising interactions with templates and constant
 expressions.
 \effect Valid \CppIII{} code may fail to compile or produce different results in
-this International Standard, as the following example illustrates:
+this International Standard.
+For example:
 
 \begin{codeblock}
 void f(void *);  // \#1
@@ -954,7 +956,8 @@
 \rationale Required for new features.
 \effect
 Valid \CppIII{} code may fail to compile or produce different results in
-this International Standard, as the following example illustrates:
+this International Standard.
+For example:
 
 \begin{codeblock}
 bool b1 = new int && false;           // previously \tcode{false}, now ill-formed
@@ -1467,6 +1470,7 @@
 by aggregate initialization.
 \effect
 Valid \CppXI{} code may fail to compile or may change meaning in this International Standard.
+For example:
 \begin{codeblock}
 struct S { // Aggregate in \CppXIV{} onwards.
   int m = 1;
@@ -1530,6 +1534,7 @@
 this International Standard. Specifically, character sequences like \tcode{0p+0}
 and \tcode{0e1_p+0} are three separate tokens each in \CppXIV{}, but one single token
 in this International Standard.
+For example:
 
 \begin{codeblock}
 #define F(a) b ## a
@@ -1588,7 +1593,8 @@
 \rationale Improve type-safety.
 \effect
 Valid \CppXIV{} code may fail to compile or change meaning in this
-International Standard:
+International Standard.
+For example:
 
 \begin{codeblock}
 void g1() noexcept;
@@ -1605,7 +1611,8 @@
 Valid \CppXIV{} code may fail to compile or produce different results in this
 International Standard; initialization from an empty initializer list will
 perform aggregate initialization instead of invoking a default constructor
-for the affected types:
+for the affected types.
+For example:
 \begin{codeblock}
 struct derived;
 struct base {
@@ -1655,7 +1662,8 @@
 allows partial specializations to decompose
 from the type deduced for the non-type template argument.
 \effect Valid \CppXIV{} code may fail to compile
-or produce different results in this International Standard:
+or produce different results in this International Standard.
+For example:
 \begin{codeblock}
 template <int N> struct A;
 template <typename T, T N> int foo(A<N> *) = delete;
@@ -1863,6 +1871,26 @@
 if those entities are only referenced in contexts
 that do not result in an odr-use.
 
+\rSec2[diff.cpp17.special]{\ref{special}: special member functions}
+
+\diffrefs{class.ctor}{class.dtor}
+\change
+A \grammarterm{simple-template-id}
+is no longer valid as the \grammarterm{declarator-id} of a constructor or destructor.
+\rationale
+Remove potentially error-prone option for redundancy.
+\effect
+Valid \CppXVII{} code may fail to compile
+in this International Standard. For example:
+\begin{codeblock}
+template<class T>
+struct A {
+  A<T>();          // error: \grammarterm{simple-template-id} not allowed for constructor
+  A(int);          // OK, \grammarterm{injected-class-name} used
+  ~A<T>();         // error: \grammarterm{simple-template-id} not allowed for destructor
+};
+\end{codeblock}
+
 \rSec2[diff.cpp17.temp]{\ref{temp}: templates}
 
 \diffref{temp.names}

source/declarations.tex

@@ -1692,6 +1692,10 @@
 Redeclarations or specializations of a function or function template with a
 declared return type that uses a placeholder type shall also use that
 placeholder, not a deduced type.
+Similarly,
+redeclarations or specializations of a function or function template with a
+declared return type that does not use a placeholder type
+shall not use a placeholder.
 \begin{example}
 \begin{codeblock}
 auto f();

source/declarators.tex

@@ -3160,6 +3160,16 @@
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in~\ref{dcl.init}.
 
+\pnum
+The destructor for each element of class type
+is potentially invoked\iref{class.dtor}
+from the context where the aggregate initialization occurs.
+\begin{note}
+This provision ensures that destructors can be called
+for fully-constructed subobjects
+in case an exception is thrown\iref{except.ctor}.
+\end{note}
+
 \pnum
 An array of unknown bound initialized with a
 brace-enclosed