[std] Use \keyword for 'auto'.

Author: jensmaurer

source/classes.tex

@@ -6346,11 +6346,11 @@
 
 \begin{itemize}
 \item
-for an \tcode{operator<=>} whose return type is not \tcode{auto},
+for an \tcode{operator<=>} whose return type is not \keyword{auto},
 when determining whether a synthesized three-way comparison is defined,
 
 \item
-for an \tcode{operator<=>} whose return type is \tcode{auto} or
+for an \tcode{operator<=>} whose return type is \keyword{auto} or
 for an \tcode{operator==},
 for a comparison between an element of the expanded list of
 subobjects and itself, or
@@ -6528,7 +6528,7 @@
 
 \begin{itemize}
 \item
-If \tcode{R} is \tcode{auto}, then
+If \tcode{R} is \keyword{auto}, then
 let $\cv{}_i~\tcode{R}_i$ be
 the type of the expression $\tcode{x}_i\tcode{ <=> }\tcode{x}_i$.
 The operator function is defined as deleted

source/compatibility.tex

@@ -799,7 +799,7 @@
 
 \diffref{dcl.spec.auto}
 \change
-\tcode{auto} deduction from \grammarterm{braced-init-list}.
+\keyword{auto} deduction from \grammarterm{braced-init-list}.
 \rationale
 More intuitive deduction behavior.
 \effect
@@ -1352,15 +1352,15 @@
 
 \diffref{dcl.spec}
 \change
-Remove \tcode{auto} as a storage class specifier.
+Remove \keyword{auto} as a storage class specifier.
 \rationale
 New feature.
 \effect
-Valid \CppIII{} code that uses the keyword \tcode{auto} as a storage class
+Valid \CppIII{} code that uses the keyword \keyword{auto} as a storage class
 specifier
 may be invalid in this revision of \Cpp{}.
 In this revision of \Cpp{},
-\tcode{auto} indicates that the type of a variable is to be deduced
+\keyword{auto} indicates that the type of a variable is to be deduced
 from its initializer expression.
 
 \diffref{dcl.init.list}
@@ -2270,7 +2270,7 @@
 
 \diffref{dcl.spec.auto}
 \change
-The keyword \tcode{auto} cannot be used as a storage class specifier.
+The keyword \keyword{auto} cannot be used as a storage class specifier.
 
 \begin{codeblock}
 void f() {
@@ -2279,9 +2279,9 @@
 \end{codeblock}
 
 \rationale
-Allowing the use of \tcode{auto} to deduce the type
+Allowing the use of \keyword{auto} to deduce the type
 of a variable from its initializer results in undesired interpretations of
-\tcode{auto} as a storage class specifier in certain contexts.
+\keyword{auto} as a storage class specifier in certain contexts.
 \effect
 Deletion of semantically well-defined feature.
 \difficulty

source/declarations.tex

@@ -174,7 +174,7 @@
 a \defn{structured binding declaration}\iref{dcl.struct.bind}.
 If the \grammarterm{decl-specifier-seq} contains
 any \grammarterm{decl-specifier} other than
-\tcode{static}, \tcode{thread_local}, \tcode{auto}\iref{dcl.spec.auto}, or
+\tcode{static}, \tcode{thread_local}, \keyword{auto}\iref{dcl.spec.auto}, or
 \grammarterm{cv-qualifier}{s},
 the program is ill-formed.
 The \grammarterm{initializer} shall be
@@ -1666,12 +1666,12 @@
 
 \pnum
 A \grammarterm{placeholder-type-specifier} of the form
-\opt{\grammarterm{type-constraint}} \tcode{auto}
+\opt{\grammarterm{type-constraint}} \keyword{auto}
 can be used as a \grammarterm{decl-specifier} of
 the \grammarterm{decl-specifier-seq} of
 a \grammarterm{parameter-declaration} of
 a function declaration or \grammarterm{lambda-expression} and,
-if it is not the \tcode{auto} \grammarterm{type-specifier}
+if it is not the \keyword{auto} \grammarterm{type-specifier}
 introducing a \grammarterm{trailing-return-type} (see below),
 is a \defn{generic parameter type placeholder}
 of the function declaration or \grammarterm{lambda-expression}.
@@ -1716,13 +1716,13 @@
 auto x = 5;                     // OK: \tcode{x} has type \tcode{int}
 const auto *v = &x, u = 6;      // OK: \tcode{v} has type \tcode{const int*}, \tcode{u} has type \tcode{const int}
 static auto y = 0.0;            // OK: \tcode{y} has type \tcode{double}
-auto int r;                     // error: \tcode{auto} is not a \grammarterm{storage-class-specifier}
+auto int r;                     // error: \keyword{auto} is not a \grammarterm{storage-class-specifier}
 auto f() -> int;                // OK: \tcode{f} returns \tcode{int}
 auto g() { return 0.0; }        // OK: \tcode{g} returns \tcode{double}
 auto h();                       // OK: \tcode{h}'s return type will be deduced when it is defined
 \end{codeblock}
 \end{example}
-The \tcode{auto} \grammarterm{type-specifier}
+The \keyword{auto} \grammarterm{type-specifier}
 can also be used to introduce
 a structured binding declaration\iref{dcl.struct.bind}.
 
@@ -1750,8 +1750,8 @@
 
 \begin{example}
 \begin{codeblock}
-auto x = 5, *y = &x;            // OK: \tcode{auto} is \tcode{int}
-auto a = 5, b = { 1, 2 };       // error: different types for \tcode{auto}
+auto x = 5, *y = &x;            // OK: \keyword{auto} is \tcode{int}
+auto a = 5, b = { 1, 2 };       // error: different types for \keyword{auto}
 \end{codeblock}
 \end{example}
 
@@ -1836,8 +1836,8 @@
 auto f();
 auto f() { return 42; }                         // return type is \tcode{int}
 auto f();                                       // OK
-int f();                                        // error: \tcode{auto} and \tcode{int} don't match
-decltype(auto) f();                             // error: \tcode{auto} and \tcode{decltype(auto)} don't match
+int f();                                        // error: \keyword{auto} and \tcode{int} don't match
+decltype(auto) f();                             // error: \keyword{auto} and \tcode{decltype(auto)} don't match
 
 template <typename T> auto g(T t) { return t; } // \#1
 template auto g(int);                           // OK, return type is \tcode{int}
@@ -1928,7 +1928,7 @@
 or with an operand of type \keyword{void},
 \tcode{T} shall be either
 \opt{\grammarterm{type-constraint}} \tcode{decltype(auto)} or
-\cv{}~\opt{\grammarterm{type-constraint}} \tcode{auto}.
+\cv{}~\opt{\grammarterm{type-constraint}} \keyword{auto}.
 
 \pnum
 If the deduction is for a \tcode{return} statement
@@ -1937,13 +1937,13 @@
 
 \pnum
 If the \grammarterm{placeholder-type-specifier} is of the form
-\opt{\grammarterm{type-constraint}} \tcode{auto},
+\opt{\grammarterm{type-constraint}} \keyword{auto},
 the deduced type
 $\mathtt{T}'$ replacing \tcode{T}
 is determined using the rules for template argument deduction.
 Obtain \tcode{P} from
 \tcode{T} by replacing the occurrences of
-\opt{\grammarterm{type-constraint}} \tcode{auto} either with
+\opt{\grammarterm{type-constraint}} \keyword{auto} either with
 a new invented type template parameter \tcode{U} or,
 if the initialization is copy-list-initialization, with
 \tcode{std::initializer_list<U>}. Deduce a value for \tcode{U} using the rules
@@ -2149,7 +2149,7 @@
 S S;
 S T;                    // error
 \end{codeblock}
-Another exception is when \tcode{T} is \tcode{auto}\iref{dcl.spec.auto},
+Another exception is when \tcode{T} is \keyword{auto}\iref{dcl.spec.auto},
 for example:
 \begin{codeblock}
 auto i = 1, j = 2.0;    // error: deduced types for \tcode{i} and \tcode{j} do not match
@@ -3365,7 +3365,7 @@
 \tcode{D1}
 is
 ``\placeholder{derived-declarator-type-list} \tcode{T}'',
-\tcode{T} shall be the single \grammarterm{type-specifier} \tcode{auto}.
+\tcode{T} shall be the single \grammarterm{type-specifier} \keyword{auto}.
 The type of the
 \grammarterm{declarator-id}
 in
@@ -3727,11 +3727,11 @@
 one invented type \grammarterm{template-parameter}
 for each generic parameter type placeholder
 of the function declaration, in order of appearance.
-For a \grammarterm{placeholder-type-specifier} of the form \tcode{auto},
+For a \grammarterm{placeholder-type-specifier} of the form \keyword{auto},
 the invented parameter is
 an unconstrained \grammarterm{type-parameter}.
 For a \grammarterm{placeholder-type-specifier} of the form
-\grammarterm{type-constraint} \tcode{auto},
+\grammarterm{type-constraint} \keyword{auto},
 the invented parameter is a \grammarterm{type-parameter} with
 that \grammarterm{type-constraint}.
 The invented type \grammarterm{template-parameter} is
@@ -3829,7 +3829,7 @@
 of a \grammarterm{parameter-declaration-clause} without a preceding
 comma. In this case, the ellipsis is parsed as part of the
 \grammarterm{abstract-declarator} if the type of the parameter either names
-a template parameter pack that has not been expanded or contains \tcode{auto};
+a template parameter pack that has not been expanded or contains \keyword{auto};
 otherwise, it is
 parsed as part of the \grammarterm{parameter-declaration-clause}.
 \begin{footnote}

source/expressions.tex

@@ -1689,7 +1689,7 @@
 If a \grammarterm{lambda-expression} includes an empty
 \grammarterm{lambda-declarator}, it is as if the \grammarterm{lambda-declarator} were
 \tcode{()}.
-The lambda return type is \tcode{auto}, which is replaced by the
+The lambda return type is \keyword{auto}, which is replaced by the
 type specified by the
 \grammarterm{trailing-return-type} if provided and/or deduced from
 \tcode{return} statements as described in~\ref{dcl.spec.auto}.
@@ -6162,7 +6162,7 @@
 if the header \libheaderref{compare}
 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}
+(e.g., via the \keyword{auto} specifier\iref{dcl.spec.auto}
 in a defaulted three-way comparison\iref{class.spaceship}
 or use of the built-in operator) -- the program is ill-formed.
 

source/statements.tex

@@ -83,7 +83,7 @@
 declaration\iref{dcl.dcl}.
 The \grammarterm{declarator} shall not
 specify a function or an array. The \grammarterm{decl-specifier-seq} shall not
-define a class or enumeration. If the \tcode{auto} \grammarterm{type-specifier} appears in
+define a class or enumeration. If the \keyword{auto} \grammarterm{type-specifier} appears in
 the \grammarterm{decl-specifier-seq},
 the type of the identifier being declared is deduced from the initializer as described in~\ref{dcl.spec.auto}.
 

source/templates.tex

@@ -6179,7 +6179,7 @@
 template int *var<int>;         // error: instantiated variable has type \tcode{int}
 
 template<typename T> auto av = T();
-template int av<int>;           // OK, variable with type \tcode{int} can be redeclared with type \tcode{auto}
+template int av<int>;           // OK, variable with type \tcode{int} can be redeclared with type \keyword{auto}
 
 template<typename T> auto f() {}
 template void f<int>();         // error: function with deduced return type